@milaboratories/pl-model-common 1.11.1 → 1.11.2

package/src/drivers/pframe/column_filter.ts

@@ -1,4 +1,4 @@
-import { ValueType } from './spec/spec';
+import type { ValueType } from './spec/spec';
 
 /** Allows to search multiple columns in different contexts. */
 export interface ColumnFilter {
@@ -10,7 +10,7 @@ export interface ColumnFilter {
    * matching. */
   readonly name?: string[];
 
-    /** Match requires all the domains listed here to have corresponding values. */
+  /** Match requires all the domains listed here to have corresponding values. */
   readonly domainValue?: Record<string, string>;
 
   /** Match requires all the annotations listed here to have corresponding values. */

package/src/drivers/pframe/data.ts

@@ -1,5 +1,4 @@
-import { number } from 'zod';
-import { ValueType } from './spec/spec';
+import type { ValueType } from './spec/spec';
 
 export const PValueIntNA = -2147483648;
 export const PValueLongNA = -9007199254740991n;
@@ -69,9 +68,9 @@ export function isNotNAPValue(value: unknown): value is NotNAPValue;
 export function isNotNAPValue(value: unknown, valueType?: ValueType): boolean {
   if (!valueType)
     return (
-      typeof value === 'string' ||
-      (typeof value === 'number' && isFinite(value)) ||
-      typeof value === 'bigint'
+      typeof value === 'string'
+      || (typeof value === 'number' && isFinite(value))
+      || typeof value === 'bigint'
     );
   if (isValueNA(value, valueType)) return false;
   switch (valueType) {
@@ -102,10 +101,10 @@ export function isPValue(value: unknown): value is PValue;
 export function isPValue(value: unknown, valueType?: ValueType): boolean {
   if (!valueType)
     return (
-      value === null ||
-      typeof value === 'string' ||
-      typeof value === 'number' ||
-      typeof value === 'bigint'
+      value === null
+      || typeof value === 'string'
+      || typeof value === 'number'
+      || typeof value === 'bigint'
     );
   if (isValueNA(value, valueType)) return true;
   switch (valueType) {
@@ -146,10 +145,10 @@ export function toJsonSafePValue(value: PValue): PValueJsonSafe {
  */
 export function safeConvertToPValue(value: unknown, checkType?: ValueType): PValue {
   if (
-    value === null ||
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    typeof value === 'bigint'
+    value === null
+    || typeof value === 'string'
+    || typeof value === 'number'
+    || typeof value === 'bigint'
   ) {
     if (checkType && !isValueNA(value, checkType) && !isPValue(value, checkType))
       throw new Error(`Unexpected value type, got ${typeof value}, expected ${checkType}`);
@@ -157,10 +156,10 @@ export function safeConvertToPValue(value: unknown, checkType?: ValueType): PVal
   }
 
   if (
-    typeof value === 'object' &&
-    value !== null &&
-    'bigint' in value &&
-    typeof value.bigint === 'string'
+    typeof value === 'object'
+    && value !== null
+    && 'bigint' in value
+    && typeof value.bigint === 'string'
   ) {
     if (checkType && checkType !== 'Long')
       throw new Error(`Unexpected value type, got serialized bigint, expected ${checkType}`);
@@ -186,7 +185,7 @@ export function pValueToStringOrNumberOrNull(
   value: PValue | PValueJsonSafe
 ): string | number | null;
 export function pValueToStringOrNumberOrNull(
-  value: PValue | PValueJsonSafe
+  value: PValue | PValueJsonSafe,
 ): string | number | null {
   value = safeConvertToPValue(value);
   if (value === null) return null;
@@ -270,7 +269,7 @@ export type AbsentAndNAFill = {
 export function pTableValue(
   column: PTableVector,
   row: number,
-  fill: AbsentAndNAFill = {}
+  fill: AbsentAndNAFill = {},
 ): PTableValue {
   if (isValueAbsent(column.absent, row))
     return fill.absent === undefined ? PTableAbsent : fill.absent;

package/src/drivers/pframe/driver.ts

@@ -1,17 +1,17 @@
-import { Branded } from '../../branding';
-import { PTable } from './table';
-import { PFrame } from './pframe';
-import { AddParameterToAllMethods } from './type_util';
-import { PTableShape, PTableVector, TableRange } from './data';
-import { FindColumnsRequest, FindColumnsResponse } from './find_columns';
-import { PObjectId } from '../../pool';
-import { PColumnIdAndSpec, PColumnSpec } from './spec/spec';
-import {
+import type { Branded } from '../../branding';
+import type { PTable } from './table';
+import type { PFrame } from './pframe';
+import type { AddParameterToAllMethods } from './type_util';
+import type { PTableShape, PTableVector, TableRange } from './data';
+import type { FindColumnsRequest, FindColumnsResponse } from './find_columns';
+import type { PObjectId } from '../../pool';
+import type { PColumnIdAndSpec, PColumnSpec } from './spec/spec';
+import type {
   CalculateTableDataRequest,
-  CalculateTableDataResponse
+  CalculateTableDataResponse,
 } from './table_calculate';
-import { UniqueValuesRequest, UniqueValuesResponse } from './unique_values';
-import { PTableColumnSpec } from './table_common';
+import type { UniqueValuesRequest, UniqueValuesResponse } from './unique_values';
+import type { PTableColumnSpec } from './table_common';
 
 /** PFrame handle */
 export type PFrameHandle = Branded<string, 'PFrame'>;
@@ -105,6 +105,6 @@ type ExpectedPFrameDriverType = ExpectedPFrameDriverTypeF &
   ExpectedPFrameDriverTypeT;
 
 type TypeEqualityGuard<A, B> = Exclude<A, B> | Exclude<B, A>;
-function assert<T extends never>() {}
+function assert<_T extends never>() {}
 
 assert<TypeEqualityGuard<PFrameDriver, ExpectedPFrameDriverType>>();

package/src/drivers/pframe/find_columns.ts

@@ -1,5 +1,5 @@
-import { ColumnFilter } from './column_filter';
-import { AxisId, PColumnIdAndSpec } from './spec/spec';
+import type { ColumnFilter } from './column_filter';
+import type { AxisId, PColumnIdAndSpec } from './spec/spec';
 
 /**
  * Request to search among existing columns in the PFrame. Two filtering

package/src/drivers/pframe/pframe.ts

@@ -1,11 +1,11 @@
-import { PObjectId } from '../../pool';
-import { FindColumnsRequest, FindColumnsResponse } from './find_columns';
-import { PColumn, PColumnIdAndSpec, PColumnSpec } from './spec/spec';
-import {
+import type { PObjectId } from '../../pool';
+import type { FindColumnsRequest, FindColumnsResponse } from './find_columns';
+import type { PColumn, PColumnIdAndSpec, PColumnSpec } from './spec/spec';
+import type {
   CalculateTableDataRequest,
-  CalculateTableDataResponse
+  CalculateTableDataResponse,
 } from './table_calculate';
-import { UniqueValuesRequest, UniqueValuesResponse } from './unique_values';
+import type { UniqueValuesRequest, UniqueValuesResponse } from './unique_values';
 
 /** Read interface exposed by PFrames library */
 export interface PFrame {

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

@@ -1,6 +1,6 @@
 import { isPColumnSpec, type PObjectSpec } from '../../../pool';
 import type { AxisId, PColumnSpec, ValueType } from './spec';
-import { getAxisId, matchAxisId } from './spec';
+import { getAxisId } from './spec';
 
 /**
  * Defines a pattern for matching axes within the PFrame data model.

package/src/drivers/pframe/table.ts

@@ -1,5 +1,5 @@
-import { PTableColumnSpec } from './table_common';
-import { PTableShape, PTableVector, TableRange } from './data';
+import type { PTableColumnSpec } from './table_common';
+import type { PTableShape, PTableVector, TableRange } from './data';
 
 /**
  * Table view.

package/src/drivers/pframe/table_calculate.ts

@@ -1,5 +1,5 @@
-import { PTableColumnId, PTableColumnSpec } from './table_common';
-import { PTableVector } from './data';
+import type { PTableColumnId, PTableColumnSpec } from './table_common';
+import type { PTableVector } from './data';
 import { assertNever } from '../../util';
 
 /** Defines a terminal column node in the join request tree */
@@ -310,32 +310,32 @@ export type CalculateTableDataResponse = FullPTableColumnData[];
 
 export function mapPTableDef<C1, C2>(
   def: PTableDef<C1>,
-  cb: (c: C1) => C2
+  cb: (c: C1) => C2,
 ): PTableDef<C2> {
   return { ...def, src: mapJoinEntry(def.src, cb) };
 }
 
 export function mapJoinEntry<C1, C2>(
   entry: JoinEntry<C1>,
-  cb: (c: C1) => C2
+  cb: (c: C1) => C2,
 ): JoinEntry<C2> {
   switch (entry.type) {
     case 'column':
       return {
         type: 'column',
-        column: cb(entry.column)
+        column: cb(entry.column),
       };
     case 'inner':
     case 'full':
       return {
         type: entry.type,
-        entries: entry.entries.map((col) => mapJoinEntry(col, cb))
+        entries: entry.entries.map((col) => mapJoinEntry(col, cb)),
       };
     case 'outer':
       return {
         type: 'outer',
         primary: mapJoinEntry(entry.primary, cb),
-        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb))
+        secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),
       };
     default:
       assertNever(entry);

package/src/drivers/pframe/table_common.ts

@@ -1,18 +1,18 @@
-import { PObjectId } from '../../pool';
-import { AxisId, AxisSpec, PColumnSpec } from './spec/spec';
+import type { PObjectId } from '../../pool';
+import type { AxisId, AxisSpec, PColumnSpec } from './spec/spec';
 
 /** Unified spec object for axes and columns */
 export type PTableColumnSpec =
   | {
-      type: 'axis';
-      id: AxisId;
-      spec: AxisSpec;
-    }
+    type: 'axis';
+    id: AxisId;
+    spec: AxisSpec;
+  }
   | {
-      type: 'column';
-      id: PObjectId;
-      spec: PColumnSpec;
-    };
+    type: 'column';
+    id: PObjectId;
+    spec: PColumnSpec;
+  };
 
 export type PTableColumnIdAxis = {
   type: 'axis';

package/src/drivers/pframe/type_util.ts

@@ -1,13 +1,15 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// TODO change to use unknown
 export type AddParameters<
   TParameters extends [...args: any],
-  TFunction extends (...args: any) => any
+  TFunction extends (...args: any) => any,
 > = (
   ...args: [...TParameters, ...Parameters<TFunction>]
 ) => ReturnType<TFunction>;
 
 export type AddParameterToAllMethods<
   Interface,
-  TParameters extends [...args: any]
+  TParameters extends [...args: any],
 > = {
   [Field in keyof Interface]: Interface[Field] extends (...args: any) => any
     ? AddParameters<TParameters, Interface[Field]>

package/src/drivers/pframe/unique_values.ts

@@ -1,7 +1,7 @@
-import { AxisId } from './spec/spec';
-import { PTableRecordFilter } from './table_calculate';
-import { PTableVector } from './data';
-import { PObjectId } from '../../pool';
+import type { AxisId } from './spec/spec';
+import type { PTableRecordFilter } from './table_calculate';
+import type { PTableVector } from './data';
+import type { PObjectId } from '../../pool';
 
 /** Calculate set of unique values for a specific axis for the filtered set of records */
 export interface UniqueValuesRequest {

package/src/navigation.ts

@@ -19,7 +19,7 @@ export type BlockSectionLink = {
 };
 
 /** Different variants for link section appearance */
-export type BlockSectionLinkAppearance = 
+export type BlockSectionLinkAppearance =
   /** Shows a section of type `link` with a `+` icon and a certain specific style */
   'add-section';
 

package/src/pool/entry.ts

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

package/src/pool/query.ts

@@ -1,37 +1,38 @@
-import { AxisId } from '../drivers';
-import { PObjectSpec, 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);
@@ -39,7 +40,7 @@ function assertNever(x: never): never {
 
 export function executePSpecPredicate(
   predicate: PSpecPredicate,
-  spec: PObjectSpec
+  spec: PObjectSpec,
 ): boolean {
   switch (predicate.type) {
     case 'and':
@@ -58,33 +59,33 @@ export function executePSpecPredicate(
       return isPColumnSpec(spec) && Boolean(spec.name.match(predicate.pattern));
     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':
       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':
       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(
+              (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
-                  )))
-          )
+                      axisSpec.domain![domain] === domainValue,
+                  ))),
+          ),
         )
       );
     default:

package/src/pool/spec.ts

@@ -1,7 +1,7 @@
-import { Branded } from '../branding';
-import { JoinEntry, PColumn, PColumnSpec } from '../drivers';
+import type { Branded } from '../branding';
+import type { JoinEntry, PColumn, PColumnSpec } from '../drivers';
 import { assertNever } from '../util';
-import { ResultPoolEntry } from './entry';
+import type { ResultPoolEntry } from './entry';
 
 /** Any object exported into the result pool by the block always have spec attached to it */
 export interface PObjectSpec {
@@ -40,13 +40,13 @@ export function isPColumn<T>(obj: PObject<T>): obj is PColumn<T> {
 }
 
 export function isPColumnSpecResult(
-  r: ResultPoolEntry<PObjectSpec>
+  r: ResultPoolEntry<PObjectSpec>,
 ): r is ResultPoolEntry<PColumnSpec> {
   return isPColumnSpec(r.obj);
 }
 
 export function isPColumnResult<T>(
-  r: ResultPoolEntry<PObject<T>>
+  r: ResultPoolEntry<PObject<T>>,
 ): r is ResultPoolEntry<PColumn<T>> {
   return isPColumnSpec(r.obj.spec);
 }
@@ -68,13 +68,13 @@ export function mapPObjectData<D1, D2>(
 ): PObject<D2> | undefined;
 export function mapPObjectData<D1, D2>(
   pObj: PObject<D1> | undefined,
-  cb: (d: D1) => D2
+  cb: (d: D1) => D2,
 ): PObject<D2> | undefined {
   return pObj === undefined
     ? undefined
     : {
         ...pObj,
-        data: cb(pObj.data)
+        data: cb(pObj.data),
       };
 }
 

package/src/ref.ts

@@ -6,12 +6,12 @@ export const PlRef = 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")
+    name: z.string().describe('Name of the output provided to the upstream block\'s output context'),
   })
   .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.',
   )
   .strict()
   .readonly();
@@ -21,18 +21,18 @@ export type Ref = PlRef;
 
 /**
  * Type guard to check if a value is a PlRef.
- * 
+ *
  * @param value - The value to check.
  * @returns True if the value is a PlRef, false otherwise.
  */
 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
   );
 }
 

package/src/value_or_error.ts

@@ -1,16 +1,16 @@
 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>,
-  cb: (value: V1) => V2
+  cb: (value: V1) => V2,
 ): ValueOrError<V2, E> {
   return voe.ok ? { ok: true, value: cb(voe.value) } : voe;
 }