Group lookups by their objc and tnam per section 10.3.3.1

Author: bkeepers

packages/styles/src/symbolology/index.ts

@@ -3,11 +3,13 @@ import type {
   BackgroundLayerSpecification,
   ExpressionFilterSpecification,
   ExpressionSpecification,
+  FilterSpecification,
   LayerSpecification,
 } from "maplibre-gl";
 import { LookupEntry } from "@enc-tiles/dai";
 import { instructionsToStyles } from "../instructions/index.js";
 import * as filters from "../filters.js";
+import { groupBy } from "../utils.js";
 
 export interface LayerConfig {
   mode: Mode;
@@ -37,33 +39,99 @@ const filterGeometryType: Record<LookupEntry["ftyp"], ExpressionSpecification> =
   };
 
 export function build(config: LayerConfig): LayerSpecification[] {
+  const lookupGroups = groupBy(getLookups(config), (lookup) => {
+    return [lookup.obcl, lookup.tnam].join("|");
+  });
+
+  const layers: LayerSpecification[] = Object.values(lookupGroups).flatMap(
+    (lookups) => {
+      if (!lookups)
+        throw new Error(
+          "This should never happen but TypeScript insists it can.",
+        );
+
+      if (lookups.length <= 1) {
+        return lookups.flatMap(lookupToLayers);
+      } else {
+        return lookupGroupToLayers(lookups);
+      }
+    },
+  );
+
+  return [background(config), ...layers];
+}
+
+/**
+ * 10.3.3.1 Look-Up Table Entry Matching
+ *
+ * > To find the symbology instruction for a specific object, enter the look-up table with the object's
+ * > class code and gather all lines that contain [`objc`]. If only a single line is found,
+ * > [`attc`] must be empty and the object is always shown with the same symbology
+ * > regardless of its description.
+ *
+ * > If there is more than one line in the look-up table, search for the first line each of whose attribute
+ * > values in [`attc`] can also be found in the attribute values of the object. If more than one attribute
+ * > value is given in the look-up table, the match to the object must be exact, in order as well as
+ * > content.
+ */
+export function lookupGroupToLayers(
+  lookups: LookupEntry[],
+): LayerSpecification[] {
+  const [fallbackLookup, ...otherLookups] = lookups;
+
+  const fallbackFilter: FilterSpecification = [
+    "!",
+    [
+      "any",
+      ...otherLookups.map((lookup) => {
+        return filters.all(...filters.attributeFilters(lookup.attc));
+      }),
+    ],
+  ];
   return [
-    background(config),
-    ...getLookups(config).flatMap((lookup, i) => {
-      return instructionsToStyles(lookup.inst).map((layer, j) => {
-        return {
-          ...layer,
-          filter: filters.all(
-            filters.scaleFilter(),
-            filterGeometryType[lookup.ftyp],
-            ...filters.attributeFilters(lookup.attc),
-            ...("filter" in layer
-              ? [layer.filter as ExpressionFilterSpecification]
-              : []),
-          ),
-          layout: {
-            ...layer.layout,
-            [`${layer.type}-sort-key`]: sortKey(lookup.dpri, layer),
-          },
-          source: "enc",
-          "source-layer": lookup.obcl,
-          id: [lookup.obcl, layer.type, lookup.rcid, i, j].join("-"),
-        };
-      });
-    }),
+    ...lookupToLayers(fallbackLookup!).map((layer) => ({
+      ...layer,
+      ...("filter" in layer
+        ? {
+            filter: filters.all(
+              fallbackFilter,
+              layer.filter as ExpressionFilterSpecification,
+            ),
+          }
+        : {}),
+    })),
+    ...otherLookups.flatMap(lookupToLayers),
   ];
 }
 
+let i = 0;
+
+export function lookupToLayers(lookup: LookupEntry): LayerSpecification[] {
+  return instructionsToStyles(lookup.inst).map((layer) => {
+    return {
+      ...layer,
+      metadata: {
+        s52: lookup,
+      },
+      filter: filters.all(
+        filters.scaleFilter(),
+        filterGeometryType[lookup.ftyp],
+        ...filters.attributeFilters(lookup.attc),
+        ...("filter" in layer
+          ? [layer.filter as ExpressionFilterSpecification]
+          : []),
+      ),
+      layout: {
+        ...layer.layout,
+        [`${layer.type}-sort-key`]: sortKey(lookup.dpri, layer),
+      },
+      source: "enc",
+      "source-layer": lookup.obcl,
+      id: [i++, lookup.obcl, lookup.ftyp].join("-"),
+    };
+  });
+}
+
 function background({ mode }: LayerConfig): BackgroundLayerSpecification {
   return {
     id: "background",

packages/styles/src/utils.ts

@@ -0,0 +1,12 @@
+// Polyfill of Object.groupBy
+export function groupBy<T>(
+  arr: T[],
+  callback: (item: T, index: number, items: T[]) => string,
+): Record<string, T[]> {
+  return arr.reduce((acc, ...args) => {
+    const key = callback(...args);
+    acc[key] ??= [];
+    acc[key].push(args[0]);
+    return acc;
+  }, {});
+}