Improve typings of exported methods, delete dead code (#1205)

Author: HarelM

src/declass.test.ts

@@ -1,4 +1,4 @@
-import {derefLayers} from './deref';
+import {derefLayers, type LayerWithRef} from './deref';
 import {describe, test, expect} from 'vitest';
 
 describe('deref', () => {
@@ -7,11 +7,11 @@ describe('deref', () => {
             {
                 'id': 'parent',
                 'type': 'line'
-            },
+            } as LayerWithRef,
             {
                 'id': 'child',
                 'ref': 'parent'
-            }
+            } as LayerWithRef
         ])).toEqual([
             {
                 'id': 'parent',
@@ -29,11 +29,11 @@ describe('deref', () => {
             {
                 'id': 'child',
                 'ref': 'parent'
-            },
+            } as LayerWithRef,
             {
                 'id': 'parent',
                 'type': 'line'
-            }
+            } as LayerWithRef
         ])).toEqual([
             {
                 'id': 'child',

src/declass.ts

@@ -1,8 +1,11 @@
 
 import {refProperties} from './util/ref_properties';
+import {LayerSpecification} from './types.g';
 
-function deref(layer, parent) {
-    const result = {};
+export type LayerWithRef = LayerSpecification & { ref?: string };
+
+function deref(layer: LayerWithRef, parent: LayerSpecification): LayerSpecification {
+    const result: Partial<LayerSpecification> = {};
 
     for (const k in layer) {
         if (k !== 'ref') {
@@ -16,23 +19,20 @@ function deref(layer, parent) {
         }
     });
 
-    return result;
+    return result as LayerSpecification;
 }
 
 /**
- * Given an array of layers, some of which may contain `ref` properties
- * whose value is the `id` of another property, return a new array where
- * such layers have been augmented with the 'type', 'source', etc. properties
- * from the parent layer, and the `ref` property has been removed.
  *
  * The input is not modified. The output may contain references to portions
  * of the input.
  *
- * @private
- * @param {Array<Layer>} layers
- * @returns {Array<Layer>}
+ * @param layers - array of layers, some of which may contain `ref` properties
+ * whose value is the `id` of another property
+ * @returns a new array where such layers have been augmented with the 'type', 'source', etc. properties
+ * from the parent layer, and the `ref` property has been removed.
  */
-export function derefLayers(layers) {
+export function derefLayers(layers: LayerWithRef[]): LayerSpecification[] {
     layers = layers.slice();
 
     const map = Object.create(null);

src/deref.test.ts

@@ -1,16 +1,17 @@
 import {groupByLayout} from './group_by_layout';
 import {describe, test, expect} from 'vitest';
+import type {LayerSpecification} from './types.g';
 
 describe('group by layout', () => {
     test('group layers whose ref properties are identical', () => {
         const a = {
             'id': 'parent',
             'type': 'line'
-        };
+        } as LayerSpecification;
         const b = {
             'id': 'child',
             'type': 'line'
-        };
+        } as LayerSpecification;
         expect(groupByLayout([a, b], {})).toEqual([[a, b]]);
         expect(groupByLayout([a, b], {})[0][0]).toBe(a);
         expect(groupByLayout([a, b], {})[0][1]).toBe(b);
@@ -21,11 +22,11 @@ describe('group by layout', () => {
             {
                 'id': 'parent',
                 'type': 'line'
-            },
+            } as LayerSpecification,
             {
                 'id': 'child',
                 'type': 'fill'
-            }
+            } as LayerSpecification
         ], {})).toEqual([
             [{
                 'id': 'parent',
@@ -43,12 +44,12 @@ describe('group by layout', () => {
                 'id': 'parent',
                 'type': 'line',
                 'layout': {'a': 1, 'b': 2}
-            },
+            } as any as LayerSpecification,
             {
                 'id': 'child',
                 'type': 'line',
                 'layout': {'b': 2, 'a': 1}
-            }
+            } as any as LayerSpecification
         ], {})).toEqual([[
             {
                 'id': 'parent',

src/deref.ts

@@ -1,7 +1,8 @@
 
 import {refProperties} from './util/ref_properties';
+import type {LayerSpecification} from './types.g';
 
-function stringify(obj) {
+function stringify(obj: any): string {
     const type = typeof obj;
     if (type === 'number' || type === 'boolean' || type === 'string' || obj === undefined || obj === null)
         return JSON.stringify(obj);
@@ -23,7 +24,7 @@ function stringify(obj) {
     return `${str}}`;
 }
 
-function getKey(layer) {
+function getKey(layer: LayerSpecification): string {
     let key = '';
     for (const k of refProperties) {
         key += `/${stringify(layer[k])}`;
@@ -32,26 +33,25 @@ function getKey(layer) {
 }
 
 /**
- * Given an array of layers, return an array of arrays of layers where all
- * layers in each group have identical layout-affecting properties. These
- * are the properties that were formerly used by explicit `ref` mechanism
+ * Groups layers by their layout-affecting properties.
+ * These are the properties that were formerly used by explicit `ref` mechanism
  * for layers: 'type', 'source', 'source-layer', 'minzoom', 'maxzoom',
  * 'filter', and 'layout'.
  *
  * The input is not modified. The output layers are references to the
  * input layers.
  *
- * @private
- * @param {Array<Layer>} layers
- * @param {Object} [cachedKeys] - an object to keep already calculated keys.
- * @returns {Array<Array<Layer>>}
+ * @param layers - an array of {@link LayerSpecification}.
+ * @param cachedKeys - an object to keep already calculated keys.
+ * @returns an array of arrays of {@link LayerSpecification} objects, where each inner array 
+ * contains layers that share the same layout-affecting properties.
  */
-export function groupByLayout(layers, cachedKeys) {
-    const groups = {};
+export function groupByLayout(layers: LayerSpecification[], cachedKeys?: Record<string, string>): LayerSpecification[][] {
+    const groups: Record<string, LayerSpecification[]> = {};
 
     for (let i = 0; i < layers.length; i++) {
 
-        const k = (cachedKeys && cachedKeys[layers[i].id]) || getKey(layers[i]);
+        const k: string = (cachedKeys && cachedKeys[layers[i].id]) || getKey(layers[i]);
         // update the cache if there is one
         if (cachedKeys)
             cachedKeys[layers[i].id] = k;
@@ -63,7 +63,7 @@ export function groupByLayout(layers, cachedKeys) {
         group.push(layers[i]);
     }
 
-    const result = [];
+    const result: LayerSpecification[][] = [];
 
     for (const k in groups) {
         result.push(groups[k]);