@milaboratories/pl-model-common 1.24.3 → 1.24.5

package/src/drivers/pframe/spec/anchored.ts

@@ -1,10 +1,18 @@
-import canonicalize from 'canonicalize';
-import type { AxisFilter, AxisFilterValue } from './filtered_column';
-import type { SUniversalPColumnId, UniversalPColumnId } from './ids';
-import { stringifyColumnId } from './ids';
-import type { AAxisSelector, AnchorAxisRef, AnchorAxisRefByIdx, AnchoredPColumnId, AnchoredPColumnSelector, AxisSelector, PColumnSelector } from './selectors';
-import type { AxisId, PColumnSpec } from './spec';
-import { getAxisId, matchAxisId } from './spec';
+import canonicalize from "canonicalize";
+import type { AxisFilter, AxisFilterValue } from "./filtered_column";
+import type { SUniversalPColumnId, UniversalPColumnId } from "./ids";
+import { stringifyColumnId } from "./ids";
+import type {
+  AAxisSelector,
+  AnchorAxisRef,
+  AnchorAxisRefByIdx,
+  AnchoredPColumnId,
+  AnchoredPColumnSelector,
+  AxisSelector,
+  PColumnSelector,
+} from "./selectors";
+import type { AxisId, PColumnSpec } from "./spec";
+import { getAxisId, matchAxisId } from "./spec";
 
 //
 // Helper functions
@@ -89,15 +97,12 @@ export class AnchoredIdDeriver {
 
     let skipDomains: Set<string> | undefined = undefined;
     if (spec.domain !== undefined) {
-      outer:
-      for (const domainPack of this.domainPacks) {
+      outer: for (const domainPack of this.domainPacks) {
         const dAnchor: string[][] = [];
         for (const domainKey of domainPack) {
           const dValue = spec.domain[domainKey];
-          if (dValue !== undefined)
-            dAnchor.push([domainKey, dValue]);
-          else
-            break outer;
+          if (dValue !== undefined) dAnchor.push([domainKey, dValue]);
+          else break outer;
         }
         const domainAnchor = this.domainPackToAnchor.get(JSON.stringify(dAnchor));
         if (domainAnchor !== undefined) {
@@ -109,8 +114,7 @@ export class AnchoredIdDeriver {
     }
 
     for (const [dKey, dValue] of Object.entries(spec.domain ?? {})) {
-      if (skipDomains !== undefined && skipDomains.has(dKey))
-        continue;
+      if (skipDomains !== undefined && skipDomains.has(dKey)) continue;
       const key = domainKey(dKey, dValue);
       const anchorId = this.domains.get(key);
       result.domain ??= {};
@@ -136,16 +140,20 @@ export class AnchoredIdDeriver {
       const [axisIdOrIndex, value] = filter;
 
       // If it's already a numeric index, validate it
-      if (typeof axisIdOrIndex === 'number') {
+      if (typeof axisIdOrIndex === "number") {
         if (axisIdOrIndex < 0 || axisIdOrIndex >= spec.axesSpec.length) {
-          throw new Error(`Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`);
+          throw new Error(
+            `Axis index ${axisIdOrIndex} is out of bounds (0-${spec.axesSpec.length - 1})`,
+          );
         }
         resolvedFilters.push([axisIdOrIndex, value]);
       } else {
         // If it's a string (axis name), resolve it to an index
         const axisIndex = spec.axesSpec.findIndex((axis) => axis.name === axisIdOrIndex);
         if (axisIndex === -1) {
-          throw new Error(`Axis with name "${axisIdOrIndex}" not found in the column specification`);
+          throw new Error(
+            `Axis with name "${axisIdOrIndex}" not found in the column specification`,
+          );
         }
         resolvedFilters.push([axisIndex, value]);
       }
@@ -191,14 +199,17 @@ export type ResolveAnchorsOptions = {
  * @param options - Options for resolving anchors
  * @returns A non-anchored column matcher with all references resolved to actual values
  */
-export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: AnchoredPColumnSelector, options?: ResolveAnchorsOptions): PColumnSelector {
+export function resolveAnchors(
+  anchors: Record<string, PColumnSpec>,
+  matcher: AnchoredPColumnSelector,
+  options?: ResolveAnchorsOptions,
+): PColumnSelector {
   const result = { ...matcher };
   const ignoreMissingDomains = options?.ignoreMissingDomains ?? false;
 
   if (result.domainAnchor !== undefined) {
     const anchorSpec = anchors[result.domainAnchor];
-    if (!anchorSpec)
-      throw new Error(`Anchor "${result.domainAnchor}" not found`);
+    if (!anchorSpec) throw new Error(`Anchor "${result.domainAnchor}" not found`);
 
     const anchorDomains = anchorSpec.domain || {};
     result.domain = { ...anchorDomains, ...result.domain };
@@ -208,7 +219,7 @@ export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: An
   if (result.domain) {
     const resolvedDomain: Record<string, string> = {};
     for (const [key, value] of Object.entries(result.domain)) {
-      if (typeof value === 'string') {
+      if (typeof value === "string") {
         resolvedDomain[key] = value;
       } else {
         // It's an AnchorDomainRef
@@ -228,8 +239,7 @@ export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: An
     result.domain = resolvedDomain;
   }
 
-  if (result.axes)
-    result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));
+  if (result.axes) result.axes = result.axes.map((axis) => resolveAxisReference(anchors, axis));
 
   return result as PColumnSelector;
 }
@@ -237,22 +247,23 @@ export function resolveAnchors(anchors: Record<string, PColumnSpec>, matcher: An
 /**
  * Resolves an anchored axis reference to a concrete AxisId
  */
-function resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAxisSelector): AxisSelector {
-  if (!isAnchorAxisRef(axisRef))
-    return axisRef;
+function resolveAxisReference(
+  anchors: Record<string, PColumnSpec>,
+  axisRef: AAxisSelector,
+): AxisSelector {
+  if (!isAnchorAxisRef(axisRef)) return axisRef;
 
   // It's an anchored reference
   const anchorId = axisRef.anchor;
   const anchorSpec = anchors[anchorId];
-  if (!anchorSpec)
-    throw new Error(`Anchor "${anchorId}" not found for axis reference`);
+  if (!anchorSpec) throw new Error(`Anchor "${anchorId}" not found for axis reference`);
 
-  if ('idx' in axisRef) {
+  if ("idx" in axisRef) {
     // AnchorAxisRefByIdx
     if (axisRef.idx < 0 || axisRef.idx >= anchorSpec.axesSpec.length)
       throw new Error(`Axis index ${axisRef.idx} out of bounds for anchor "${anchorId}"`);
     return anchorSpec.axesSpec[axisRef.idx];
-  } else if ('name' in axisRef) {
+  } else if ("name" in axisRef) {
     // AnchorAxisRefByName
     const matches = anchorSpec.axesSpec.filter((axis) => axis.name === axisRef.name);
     if (matches.length > 1)
@@ -260,7 +271,7 @@ function resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAx
     if (matches.length === 0)
       throw new Error(`Axis with name "${axisRef.name}" not found in anchor "${anchorId}"`);
     return matches[0];
-  } else if ('id' in axisRef) {
+  } else if ("id" in axisRef) {
     // AnchorAxisRefByMatcher
     const matches = anchorSpec.axesSpec.filter((axis) => matchAxisId(axisRef.id, getAxisId(axis)));
     if (matches.length > 1)
@@ -277,5 +288,5 @@ function resolveAxisReference(anchors: Record<string, PColumnSpec>, axisRef: AAx
  * Type guard to check if a value is an anchored axis reference
  */
 function isAnchorAxisRef(value: AAxisSelector): value is AnchorAxisRef {
-  return typeof value === 'object' && 'anchor' in value;
+  return typeof value === "object" && "anchor" in value;
 }

package/src/drivers/pframe/spec/filtered_column.ts

@@ -1,4 +1,4 @@
-import type { AnchoredPColumnId } from './selectors';
+import type { AnchoredPColumnId } from "./selectors";
 
 /** Value of an axis filter */
 export type AxisFilterValue = number | string;
@@ -37,5 +37,5 @@ export type FilteredPColumnId = FilteredPColumn<AnchoredPColumnId, AxisFilterByI
  * @returns True if the value is a FilteredPColumn, false otherwise
  */
 export function isFilteredPColumn(id: unknown): id is FilteredPColumn {
-  return typeof id === 'object' && id !== null && 'source' in id && 'axisFilters' in id;
+  return typeof id === "object" && id !== null && "source" in id && "axisFilters" in id;
 }

package/src/drivers/pframe/spec/ids.ts

@@ -1,8 +1,8 @@
-import type { Branded } from '../../../branding';
-import type { AnchoredPColumnId } from './selectors';
-import type { FilteredPColumnId } from './filtered_column';
-import canonicalize from 'canonicalize';
-import type { PObjectId } from '../../../pool';
+import type { Branded } from "../../../branding";
+import type { AnchoredPColumnId } from "./selectors";
+import type { FilteredPColumnId } from "./filtered_column";
+import canonicalize from "canonicalize";
+import type { PObjectId } from "../../../pool";
 /**
  * Universal column identifier optionally anchored and optionally filtered.
  */
@@ -11,7 +11,7 @@ export type UniversalPColumnId = AnchoredPColumnId | FilteredPColumnId;
 /**
  * Canonically serialized {@link UniversalPColumnId}.
  */
-export type SUniversalPColumnId = Branded<PObjectId, 'SUniversalPColumnId', '__pl_model_brand_2__'>;
+export type SUniversalPColumnId = Branded<PObjectId, "SUniversalPColumnId", "__pl_model_brand_2__">;
 
 /**
  * Canonically serializes a {@link UniversalPColumnId} to a string.

package/src/drivers/pframe/spec/index.ts

@@ -1,6 +1,6 @@
-export * from './anchored';
-export * from './ids';
-export * from './filtered_column';
-export * from './spec';
-export * from './selectors';
-export * from './native_id';
+export * from "./anchored";
+export * from "./ids";
+export * from "./filtered_column";
+export * from "./spec";
+export * from "./selectors";
+export * from "./native_id";

package/src/drivers/pframe/spec/native_id.ts

@@ -1,17 +1,15 @@
-import type { Branded } from '../../../branding';
-import { isPColumnSpec, type PObjectSpec } from '../../../pool';
-import { getAxesId } from './spec';
-import canonicalize from 'canonicalize';
-export type NativePObjectId = Branded<string, 'NativePObjectId'>;
+import type { Branded } from "../../../branding";
+import { isPColumnSpec, type PObjectSpec } from "../../../pool";
+import { getAxesId } from "./spec";
+import canonicalize from "canonicalize";
+export type NativePObjectId = Branded<string, "NativePObjectId">;
 
 export function deriveNativeId(spec: PObjectSpec): NativePObjectId {
   const result: Record<string, unknown> = {
     kind: spec.kind,
     name: spec.name,
   };
-  if (spec.domain !== undefined)
-    result.domain = spec.domain;
-  if (isPColumnSpec(spec))
-    result.axesSpec = getAxesId(spec.axesSpec);
+  if (spec.domain !== undefined) result.domain = spec.domain;
+  if (isPColumnSpec(spec)) result.axesSpec = getAxesId(spec.axesSpec);
   return canonicalize(result) as NativePObjectId;
 }

package/src/drivers/pframe/spec/selectors.test.ts

@@ -1,209 +1,233 @@
-import { describe, test, expect } from 'vitest';
-import { matchPColumn, matchAxis } from './selectors';
-import type { PColumnSpec, AxisSpec, AxisId } from './spec';
+import { describe, test, expect } from "vitest";
+import { matchPColumn, matchAxis } from "./selectors";
+import type { PColumnSpec, AxisSpec, AxisId } from "./spec";
 
-describe('matchPColumn', () => {
+describe("matchPColumn", () => {
   // Test data
   const testColumn: PColumnSpec = {
-    kind: 'PColumn',
-    name: 'testColumn',
-    valueType: 'Int',
+    kind: "PColumn",
+    name: "testColumn",
+    valueType: "Int",
     domain: {
-      domain1: 'value1',
-      domain2: 'value2',
+      domain1: "value1",
+      domain2: "value2",
     },
     axesSpec: [
       {
-        name: 'x',
-        type: 'String',
+        name: "x",
+        type: "String",
         domain: {
-          key: 'xDomain',
+          key: "xDomain",
         },
       } as AxisSpec,
       {
-        name: 'y',
-        type: 'String',
+        name: "y",
+        type: "String",
         domain: {
-          key: 'yDomain',
+          key: "yDomain",
         },
       } as AxisSpec,
     ],
     annotations: {
-      anno1: 'value1',
-      anno2: 'value2',
+      anno1: "value1",
+      anno2: "value2",
     },
   };
 
-  test('matches on name', () => {
-    expect(matchPColumn(testColumn, { name: 'testColumn' })).toBe(true);
-    expect(matchPColumn(testColumn, { name: 'wrongName' })).toBe(false);
+  test("matches on name", () => {
+    expect(matchPColumn(testColumn, { name: "testColumn" })).toBe(true);
+    expect(matchPColumn(testColumn, { name: "wrongName" })).toBe(false);
   });
 
-  test('matches on name pattern', () => {
-    expect(matchPColumn(testColumn, { namePattern: 'test.*' })).toBe(true);
-    expect(matchPColumn(testColumn, { namePattern: 'wrong.*' })).toBe(false);
+  test("matches on name pattern", () => {
+    expect(matchPColumn(testColumn, { namePattern: "test.*" })).toBe(true);
+    expect(matchPColumn(testColumn, { namePattern: "wrong.*" })).toBe(false);
   });
 
-  test('matches on value type', () => {
-    expect(matchPColumn(testColumn, { type: 'Int' })).toBe(true);
-    expect(matchPColumn(testColumn, { type: 'String' })).toBe(false);
-    expect(matchPColumn(testColumn, { type: ['Int', 'Double'] })).toBe(true);
-    expect(matchPColumn(testColumn, { type: ['String', 'Float'] })).toBe(false);
+  test("matches on value type", () => {
+    expect(matchPColumn(testColumn, { type: "Int" })).toBe(true);
+    expect(matchPColumn(testColumn, { type: "String" })).toBe(false);
+    expect(matchPColumn(testColumn, { type: ["Int", "Double"] })).toBe(true);
+    expect(matchPColumn(testColumn, { type: ["String", "Float"] })).toBe(false);
   });
 
-  test('matches on domain', () => {
-    expect(matchPColumn(testColumn, { domain: { domain1: 'value1' } })).toBe(true);
-    expect(matchPColumn(testColumn, { domain: { domain1: 'wrongValue' } })).toBe(false);
-    expect(matchPColumn(testColumn, { domain: { nonExistentDomain: 'value' } })).toBe(false);
+  test("matches on domain", () => {
+    expect(matchPColumn(testColumn, { domain: { domain1: "value1" } })).toBe(true);
+    expect(matchPColumn(testColumn, { domain: { domain1: "wrongValue" } })).toBe(false);
+    expect(matchPColumn(testColumn, { domain: { nonExistentDomain: "value" } })).toBe(false);
   });
 
-  test('matches on axes', () => {
-    expect(matchPColumn(testColumn, {
-      axes: [
-        {
-          name: 'x',
-          type: 'String',
-          domain: {
-            key: 'xDomain',
+  test("matches on axes", () => {
+    expect(
+      matchPColumn(testColumn, {
+        axes: [
+          {
+            name: "x",
+            type: "String",
+            domain: {
+              key: "xDomain",
+            },
           },
-        },
-        {
-          name: 'y',
-          type: 'String',
-          domain: {
-            key: 'yDomain',
+          {
+            name: "y",
+            type: "String",
+            domain: {
+              key: "yDomain",
+            },
           },
-        },
-      ],
-    })).toBe(true);
+        ],
+      }),
+    ).toBe(true);
 
     // Test partial match
-    expect(matchPColumn(testColumn, {
-      axes: [{
-        name: 'x',
-        domain: {
-          key: 'xDomain',
-        },
-      }],
-      partialAxesMatch: true,
-    })).toBe(true);
+    expect(
+      matchPColumn(testColumn, {
+        axes: [
+          {
+            name: "x",
+            domain: {
+              key: "xDomain",
+            },
+          },
+        ],
+        partialAxesMatch: true,
+      }),
+    ).toBe(true);
 
     // Test failed match (wrong axis)
-    expect(matchPColumn(testColumn, {
-      axes: [{
-        name: 'z',
-        type: 'String',
-        domain: {
-          key: 'zDomain',
-        },
-      }],
-      partialAxesMatch: true,
-    })).toBe(false);
+    expect(
+      matchPColumn(testColumn, {
+        axes: [
+          {
+            name: "z",
+            type: "String",
+            domain: {
+              key: "zDomain",
+            },
+          },
+        ],
+        partialAxesMatch: true,
+      }),
+    ).toBe(false);
 
     // Test failed match (count mismatch with exact matching)
-    expect(matchPColumn(testColumn, {
-      axes: [{
-        name: 'x',
-        type: 'String',
-        domain: {
-          key: 'xDomain',
-        },
-      }],
-    })).toBe(false);
+    expect(
+      matchPColumn(testColumn, {
+        axes: [
+          {
+            name: "x",
+            type: "String",
+            domain: {
+              key: "xDomain",
+            },
+          },
+        ],
+      }),
+    ).toBe(false);
   });
 
-  test('matches on annotations', () => {
-    expect(matchPColumn(testColumn, { annotations: { anno1: 'value1' } })).toBe(true);
-    expect(matchPColumn(testColumn, { annotations: { anno1: 'wrongValue' } })).toBe(false);
-    expect(matchPColumn(testColumn, { annotations: { nonExistentAnno: 'value' } })).toBe(false);
+  test("matches on annotations", () => {
+    expect(matchPColumn(testColumn, { annotations: { anno1: "value1" } })).toBe(true);
+    expect(matchPColumn(testColumn, { annotations: { anno1: "wrongValue" } })).toBe(false);
+    expect(matchPColumn(testColumn, { annotations: { nonExistentAnno: "value" } })).toBe(false);
   });
 
-  test('matches on annotation patterns', () => {
-    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: 'value\\d' } })).toBe(true);
-    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: 'wrong.*' } })).toBe(false);
-    expect(matchPColumn(testColumn, { annotationPatterns: { nonExistentAnno: '.*' } })).toBe(false);
+  test("matches on annotation patterns", () => {
+    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: "value\\d" } })).toBe(true);
+    expect(matchPColumn(testColumn, { annotationPatterns: { anno1: "wrong.*" } })).toBe(false);
+    expect(matchPColumn(testColumn, { annotationPatterns: { nonExistentAnno: ".*" } })).toBe(false);
   });
 
-  test('matches on multiple criteria', () => {
-    expect(matchPColumn(testColumn, {
-      name: 'testColumn',
-      type: 'Int',
-      domain: { domain1: 'value1' },
-      annotations: { anno1: 'value1' },
-    })).toBe(true);
-
-    expect(matchPColumn(testColumn, {
-      name: 'testColumn',
-      type: 'Int',
-      domain: { domain1: 'wrongValue' }, // This will fail
-      annotations: { anno1: 'value1' },
-    })).toBe(false);
+  test("matches on multiple criteria", () => {
+    expect(
+      matchPColumn(testColumn, {
+        name: "testColumn",
+        type: "Int",
+        domain: { domain1: "value1" },
+        annotations: { anno1: "value1" },
+      }),
+    ).toBe(true);
+
+    expect(
+      matchPColumn(testColumn, {
+        name: "testColumn",
+        type: "Int",
+        domain: { domain1: "wrongValue" }, // This will fail
+        annotations: { anno1: "value1" },
+      }),
+    ).toBe(false);
   });
 });
 
-describe('matchAxis', () => {
+describe("matchAxis", () => {
   // Test data
   const testAxis: AxisId = {
-    name: 'testAxis',
-    type: 'String',
+    name: "testAxis",
+    type: "String",
     domain: {
-      key1: 'value1',
-      key2: 'value2',
+      key1: "value1",
+      key2: "value2",
     },
   };
 
-  test('matches on axis name', () => {
-    expect(matchAxis({ name: 'testAxis' }, testAxis)).toBe(true);
-    expect(matchAxis({ name: 'wrongAxis' }, testAxis)).toBe(false);
+  test("matches on axis name", () => {
+    expect(matchAxis({ name: "testAxis" }, testAxis)).toBe(true);
+    expect(matchAxis({ name: "wrongAxis" }, testAxis)).toBe(false);
   });
 
-  test('matches on axis type', () => {
-    expect(matchAxis({ type: 'String' }, testAxis)).toBe(true);
-    expect(matchAxis({ type: 'Int' }, testAxis)).toBe(false);
-    expect(matchAxis({ type: ['String', 'Int'] }, testAxis)).toBe(true);
-    expect(matchAxis({ type: ['Int', 'Double'] }, testAxis)).toBe(false);
+  test("matches on axis type", () => {
+    expect(matchAxis({ type: "String" }, testAxis)).toBe(true);
+    expect(matchAxis({ type: "Int" }, testAxis)).toBe(false);
+    expect(matchAxis({ type: ["String", "Int"] }, testAxis)).toBe(true);
+    expect(matchAxis({ type: ["Int", "Double"] }, testAxis)).toBe(false);
   });
 
-  test('matches on axis domain', () => {
-    expect(matchAxis({ domain: { key1: 'value1' } }, testAxis)).toBe(true);
-    expect(matchAxis({ domain: { key1: 'wrongValue' } }, testAxis)).toBe(false);
-    expect(matchAxis({ domain: { nonExistentKey: 'value' } }, testAxis)).toBe(false);
+  test("matches on axis domain", () => {
+    expect(matchAxis({ domain: { key1: "value1" } }, testAxis)).toBe(true);
+    expect(matchAxis({ domain: { key1: "wrongValue" } }, testAxis)).toBe(false);
+    expect(matchAxis({ domain: { nonExistentKey: "value" } }, testAxis)).toBe(false);
   });
 
-  test('matches on multiple axis criteria', () => {
-    expect(matchAxis(
-      {
-        name: 'testAxis',
-        type: 'String',
-        domain: { key1: 'value1' },
-      },
-      testAxis,
-    )).toBe(true);
-
-    expect(matchAxis(
-      {
-        name: 'testAxis',
-        type: 'String',
-        domain: { key1: 'wrongValue' }, // This will fail
-      },
-      testAxis,
-    )).toBe(false);
-
-    expect(matchAxis(
-      {
-        name: 'testAxis',
-        type: 'Int', // This will fail
-        domain: { key1: 'value1' },
-      },
-      testAxis,
-    )).toBe(false);
+  test("matches on multiple axis criteria", () => {
+    expect(
+      matchAxis(
+        {
+          name: "testAxis",
+          type: "String",
+          domain: { key1: "value1" },
+        },
+        testAxis,
+      ),
+    ).toBe(true);
+
+    expect(
+      matchAxis(
+        {
+          name: "testAxis",
+          type: "String",
+          domain: { key1: "wrongValue" }, // This will fail
+        },
+        testAxis,
+      ),
+    ).toBe(false);
+
+    expect(
+      matchAxis(
+        {
+          name: "testAxis",
+          type: "Int", // This will fail
+          domain: { key1: "value1" },
+        },
+        testAxis,
+      ),
+    ).toBe(false);
   });
 
-  test('matches with empty domain criteria', () => {
+  test("matches with empty domain criteria", () => {
     expect(matchAxis({ domain: {} }, testAxis)).toBe(true);
   });
 
-  test('matches with partial domain criteria', () => {
-    expect(matchAxis({ domain: { key1: 'value1' } }, testAxis)).toBe(true);
+  test("matches with partial domain criteria", () => {
+    expect(matchAxis({ domain: { key1: "value1" } }, testAxis)).toBe(true);
   });
 });