@milaboratories/pl-model-common 1.24.3 → 1.24.5

package/src/plid.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { base32Encode } from './base32_encode';
+import { z } from "zod";
+import { base32Encode } from "./base32_encode";
 
 /** Number of raw bytes in the PlId. */
 export const PlIdBytes = 15;
@@ -10,22 +10,22 @@ export const PlId = z
   .string()
   .length(PlIdLength)
   .regex(/[ABCDEFGHIJKLMNOPQRSTUVWXYZ234567]/) // RFC4648
-  .brand('PlId');
+  .brand("PlId");
 export type PlId = z.infer<typeof PlId>;
 
 export function uniquePlId(): PlId {
   const data = new Uint8Array(PlIdBytes);
   crypto.getRandomValues(data);
-  return PlId.parse(base32Encode(data, 'RFC4648'));
+  return PlId.parse(base32Encode(data, "RFC4648"));
 }
 
 export function plId(bytes: Uint8Array): PlId {
   if (bytes.length !== PlIdBytes) throw new Error(`Wrong number of bytes: ${bytes.length}`);
-  return PlId.parse(base32Encode(bytes, 'RFC4648'));
+  return PlId.parse(base32Encode(bytes, "RFC4648"));
 }
 
 export async function digestPlId(data: string): Promise<PlId> {
   const encoder = new TextEncoder();
-  const bytes = await crypto.subtle.digest('SHA-256', encoder.encode(data));
+  const bytes = await crypto.subtle.digest("SHA-256", encoder.encode(data));
   return plId(new Uint8Array(bytes.slice(0, 15)));
 }

package/src/pool/entry.ts

@@ -1,4 +1,4 @@
-import type { PlRef } from '../ref';
+import type { PlRef } from "../ref";
 
 /** Result pool entry */
 export type ResultPoolEntry<O> = {

package/src/pool/index.ts

@@ -1,3 +1,3 @@
-export * from './entry';
-export * from './spec';
-export * from './query';
+export * from "./entry";
+export * from "./spec";
+export * from "./query";

package/src/pool/query.ts

@@ -1,89 +1,85 @@
-import type { AxisId } from '../drivers';
-import type { PObjectSpec } from './spec';
-import { isPColumnSpec } from './spec';
+import type { AxisId } from "../drivers";
+import type { PObjectSpec } from "./spec";
+import { isPColumnSpec } from "./spec";
 
 export type PSpecPredicate =
   | {
-    type: 'and' | 'or';
-    operands: PSpecPredicate[];
-  }
+      type: "and" | "or";
+      operands: PSpecPredicate[];
+    }
   | {
-    type: 'not';
-    operand: PSpecPredicate;
-  }
+      type: "not";
+      operand: PSpecPredicate;
+    }
   | {
-    type: 'name';
-    name: string;
-  }
+      type: "name";
+      name: string;
+    }
   | {
-    type: 'name_pattern';
-    pattern: string;
-  }
+      type: "name_pattern";
+      pattern: string;
+    }
   | {
-    type: 'annotation';
-    annotation: string;
-    value: string;
-  }
+      type: "annotation";
+      annotation: string;
+      value: string;
+    }
   | {
-    type: 'annotation_pattern';
-    annotation: string;
-    pattern: string;
-  }
+      type: "annotation_pattern";
+      annotation: string;
+      pattern: string;
+    }
   | {
-    type: 'has_axes';
-    axes: Partial<AxisId>[];
-  };
+      type: "has_axes";
+      axes: Partial<AxisId>[];
+    };
 
 function assertNever(x: never): never {
-  throw new Error('Unexpected object: ' + x); // This is ok, because this is a possible runtime error
+  throw new Error("Unexpected object: " + x); // This is ok, because this is a possible runtime error
 }
 
-export function executePSpecPredicate(
-  predicate: PSpecPredicate,
-  spec: PObjectSpec,
-): boolean {
+export function executePSpecPredicate(predicate: PSpecPredicate, spec: PObjectSpec): boolean {
   switch (predicate.type) {
-    case 'and':
+    case "and":
       for (const operator of predicate.operands)
         if (!executePSpecPredicate(operator, spec)) return false;
       return true;
-    case 'or':
+    case "or":
       for (const operator of predicate.operands)
         if (executePSpecPredicate(operator, spec)) return true;
       return false;
-    case 'not':
+    case "not":
       return !executePSpecPredicate(predicate.operand, spec);
-    case 'name':
+    case "name":
       return isPColumnSpec(spec) && spec.name === predicate.name;
-    case 'name_pattern':
+    case "name_pattern":
       return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
-    case 'annotation':
+    case "annotation":
       return (
-        isPColumnSpec(spec)
-        && spec.annotations !== undefined
-        && spec.annotations[predicate.annotation] === predicate.value
+        isPColumnSpec(spec) &&
+        spec.annotations !== undefined &&
+        spec.annotations[predicate.annotation] === predicate.value
       );
-    case 'annotation_pattern':
+    case "annotation_pattern":
       return (
-        isPColumnSpec(spec)
-        && spec.annotations !== undefined
-        && spec.annotations[predicate.annotation] !== undefined
-        && Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))
+        isPColumnSpec(spec) &&
+        spec.annotations !== undefined &&
+        spec.annotations[predicate.annotation] !== undefined &&
+        Boolean(spec.annotations[predicate.annotation].match(predicate.pattern))
       );
-    case 'has_axes':
+    case "has_axes":
       return (
-        isPColumnSpec(spec)
-        && predicate.axes.every((matcher) =>
+        isPColumnSpec(spec) &&
+        predicate.axes.every((matcher) =>
           spec.axesSpec.some(
             (axisSpec) =>
-              (matcher.type === undefined || matcher.type === axisSpec.type)
-              && (matcher.name === undefined || matcher.name === axisSpec.name)
-              && (matcher.domain === undefined
-                || Object.keys(matcher.domain).length === 0
-                || (axisSpec.domain !== undefined
-                  && Object.entries(matcher.domain).every(
-                    ([domain, domainValue]) =>
-                      axisSpec.domain![domain] === domainValue,
+              (matcher.type === undefined || matcher.type === axisSpec.type) &&
+              (matcher.name === undefined || matcher.name === axisSpec.name) &&
+              (matcher.domain === undefined ||
+                Object.keys(matcher.domain).length === 0 ||
+                (axisSpec.domain !== undefined &&
+                  Object.entries(matcher.domain).every(
+                    ([domain, domainValue]) => axisSpec.domain![domain] === domainValue,
                   ))),
           ),
         )

package/src/pool/spec.ts

@@ -1,7 +1,7 @@
-import type { Branded } from '../branding';
-import type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from '../drivers';
-import { assertNever } from '../util';
-import type { ResultPoolEntry } from './entry';
+import type { Branded } from "../branding";
+import type { JoinEntry, PColumn, PColumnLazy, PColumnSpec } from "../drivers";
+import { assertNever } from "../util";
+import type { ResultPoolEntry } from "./entry";
 
 /** Any object exported into the result pool by the block always have spec attached to it */
 export type PObjectSpec = {
@@ -19,7 +19,7 @@ export type PObjectSpec = {
 };
 
 /** Stable PObject id */
-export type PObjectId = Branded<string, 'PColumnId'>;
+export type PObjectId = Branded<string, "PColumnId">;
 
 /**
  * Full PObject representation.
@@ -38,7 +38,7 @@ export interface PObject<Data> {
 }
 
 export function isPColumnSpec(spec: PObjectSpec): spec is PColumnSpec {
-  return spec.kind === 'PColumn';
+  return spec.kind === "PColumn";
 }
 
 export function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {
@@ -62,16 +62,19 @@ export function ensurePColumn<T>(obj: PObject<T>): PColumn<T> {
   return obj;
 }
 
-export function mapPObjectData<D1, D2>(pObj: PColumn<D1> | PColumnLazy<D1>, cb: (d: D1) => D2): PColumn<D2>;
+export function mapPObjectData<D1, D2>(
+  pObj: PColumn<D1> | PColumnLazy<D1>,
+  cb: (d: D1) => D2,
+): PColumn<D2>;
 export function mapPObjectData<D1, D2>(pObj: PColumn<D1>, cb: (d: D1) => D2): PColumn<D2>;
 export function mapPObjectData<D1, D2>(
   pObj: PColumn<D1> | undefined,
-  cb: (d: D1) => D2
+  cb: (d: D1) => D2,
 ): PColumn<D2> | undefined;
 export function mapPObjectData<D1, D2>(pObj: PObject<D1>, cb: (d: D1) => D2): PObject<D2>;
 export function mapPObjectData<D1, D2>(
   pObj: PObject<D1> | undefined,
-  cb: (d: D1) => D2
+  cb: (d: D1) => D2,
 ): PObject<D2> | undefined;
 export function mapPObjectData<D1, D2>(
   pObj: PObject<D1> | undefined,
@@ -81,7 +84,7 @@ export function mapPObjectData<D1, D2>(
     ? undefined
     : {
         ...pObj,
-        data: cb(typeof pObj.data === 'function' ? pObj.data() : pObj.data),
+        data: cb(typeof pObj.data === "function" ? pObj.data() : pObj.data),
       };
 }
 
@@ -89,22 +92,22 @@ export function extractAllColumns<D>(entry: JoinEntry<PColumn<D>>): PColumn<D>[]
   const columns = new Map<PObjectId, PColumn<D>>();
   const addAllColumns = (entry: JoinEntry<PColumn<D>>) => {
     switch (entry.type) {
-      case 'column':
+      case "column":
         columns.set(entry.column.id, entry.column);
         return;
-      case 'slicedColumn':
+      case "slicedColumn":
         columns.set(entry.column.id, entry.column);
         return;
-      case 'artificialColumn':
+      case "artificialColumn":
         columns.set(entry.column.id, entry.column);
         return;
-      case 'inlineColumn':
+      case "inlineColumn":
         return;
-      case 'full':
-      case 'inner':
+      case "full":
+      case "inner":
         for (const e of entry.entries) addAllColumns(e);
         return;
-      case 'outer':
+      case "outer":
         addAllColumns(entry.primary);
         for (const e of entry.secondary) addAllColumns(e);
         return;

package/src/ref.ts

@@ -1,22 +1,24 @@
-import { z } from 'zod';
+import { z } from "zod";
 
 export const PlRef = z
   .object({
     __isRef: z
       .literal(true)
-      .describe('Crucial marker for the block dependency tree reconstruction'),
-    blockId: z.string()
-      .describe('Upstream block id'),
-    name: z.string()
-      .describe('Name of the output provided to the upstream block\'s output context'),
-    requireEnrichments: z.literal(true).optional()
-      .describe('True if current block that stores this reference in its args, may need enrichments '
-        + 'for the references value originating from the blocks in between current and referenced block'),
+      .describe("Crucial marker for the block dependency tree reconstruction"),
+    blockId: z.string().describe("Upstream block id"),
+    name: z.string().describe("Name of the output provided to the upstream block's output context"),
+    requireEnrichments: z
+      .literal(true)
+      .optional()
+      .describe(
+        "True if current block that stores this reference in its args, may need enrichments " +
+          "for the references value originating from the blocks in between current and referenced block",
+      ),
   })
   .describe(
-    'Universal reference type, allowing to set block connections. It is crucial that '
-    + '{@link __isRef} is present and equal to true, internal logic relies on this marker '
-    + 'to build block dependency trees.',
+    "Universal reference type, allowing to set block connections. It is crucial that " +
+      "{@link __isRef} is present and equal to true, internal logic relies on this marker " +
+      "to build block dependency trees.",
   )
   .readonly();
 export type PlRef = z.infer<typeof PlRef>;
@@ -31,12 +33,12 @@ export type Ref = PlRef;
  */
 export function isPlRef(value: unknown): value is PlRef {
   return (
-    typeof value === 'object'
-    && value !== null
-    && '__isRef' in value
-    && (value as { __isRef: unknown }).__isRef === true
-    && 'blockId' in value
-    && 'name' in value
+    typeof value === "object" &&
+    value !== null &&
+    "__isRef" in value &&
+    (value as { __isRef: unknown }).__isRef === true &&
+    "blockId" in value &&
+    "name" in value
   );
 }
 
@@ -97,5 +99,9 @@ export function withEnrichments(ref: PlRef, requireEnrichments: boolean = true):
 
 /** Compare two PlRefs and returns true if they are qual */
 export function plRefsEqual(ref1: PlRef, ref2: PlRef, ignoreEnrichments: boolean = false) {
-  return ref1.blockId === ref2.blockId && ref1.name === ref2.name && (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments);
+  return (
+    ref1.blockId === ref2.blockId &&
+    ref1.name === ref2.name &&
+    (ignoreEnrichments || ref1.requireEnrichments === ref2.requireEnrichments)
+  );
 }

package/src/utag.ts

@@ -1,4 +1,4 @@
-import type { AuthorMarker } from './author_marker';
+import type { AuthorMarker } from "./author_marker";
 
 /** Value returned for changing states supporting reactive listening for changes */
 export interface ValueWithUTag<V> {

package/src/util.ts

@@ -1,5 +1,5 @@
 export function assertNever(x: never): never {
-  throw new Error('Unexpected object: ' + x); // This is ok, because this is a possible runtime error
+  throw new Error("Unexpected object: " + x); // This is ok, because this is a possible runtime error
 }
 
 /**

package/src/value_or_error.ts

@@ -1,12 +1,12 @@
 export type ValueOrError<V, E> =
   | {
-    ok: true;
-    value: V;
-  }
+      ok: true;
+      value: V;
+    }
   | {
-    ok: false;
-    error: E;
-  };
+      ok: false;
+      error: E;
+    };
 
 export function mapValueInVOE<V1, V2, E>(
   voe: ValueOrError<V1, E>,