@milaboratories/pl-model-common 1.24.2 → 1.24.4

package/src/drivers/pframe/table_calculate.ts

@@ -1,14 +1,14 @@
-import type { PTableColumnId, PTableColumnSpec } from './table_common';
-import type { PTableVector } from './data_types';
-import type { PObjectId } from '../../pool';
-import { assertNever } from '../../util';
-import type { PColumn } from './spec/spec';
-import type { PColumnValues } from './data_info';
+import type { PTableColumnId, PTableColumnSpec } from "./table_common";
+import type { PTableVector } from "./data_types";
+import type { PObjectId } from "../../pool";
+import { assertNever } from "../../util";
+import type { PColumn } from "./spec/spec";
+import type { PColumnValues } from "./data_info";
 
 /** Defines a terminal column node in the join request tree */
 export interface ColumnJoinEntry<Col> {
   /** Node type discriminator */
-  readonly type: 'column';
+  readonly type: "column";
 
   /** Local column */
   readonly column: Col;
@@ -20,7 +20,7 @@ export interface ColumnJoinEntry<Col> {
  * */
 export interface ConstantAxisFilter {
   /** Filter type discriminator */
-  readonly type: 'constant';
+  readonly type: "constant";
 
   /** Index of axis to slice (zero-based) */
   readonly axisIndex: number;
@@ -32,7 +32,7 @@ export interface ConstantAxisFilter {
 /** Defines a terminal column node in the join request tree */
 export interface SlicedColumnJoinEntry<Col> {
   /** Node type discriminator */
-  readonly type: 'slicedColumn';
+  readonly type: "slicedColumn";
 
   /** Local column */
   readonly column: Col;
@@ -46,7 +46,7 @@ export interface SlicedColumnJoinEntry<Col> {
 
 export interface ArtificialColumnJoinEntry<Col> {
   /** Node type discriminator */
-  readonly type: 'artificialColumn';
+  readonly type: "artificialColumn";
 
   /** Column definition */
   readonly column: Col;
@@ -61,7 +61,7 @@ export interface ArtificialColumnJoinEntry<Col> {
 /** Defines a terminal column node in the join request tree */
 export interface InlineColumnJoinEntry {
   /** Node type discriminator */
-  readonly type: 'inlineColumn';
+  readonly type: "inlineColumn";
 
   /** Column definition */
   readonly column: PColumn<PColumnValues>;
@@ -73,7 +73,7 @@ export interface InlineColumnJoinEntry {
  * */
 export interface InnerJoin<Col> {
   /** Node type discriminator */
-  readonly type: 'inner';
+  readonly type: "inner";
 
   /** Child nodes to be inner joined */
   readonly entries: JoinEntry<Col>[];
@@ -87,7 +87,7 @@ export interface InnerJoin<Col> {
  * */
 export interface FullJoin<Col> {
   /** Node type discriminator */
-  readonly type: 'full';
+  readonly type: "full";
 
   /** Child nodes to be fully outer joined */
   readonly entries: JoinEntry<Col>[];
@@ -105,7 +105,7 @@ export interface FullJoin<Col> {
  * */
 export interface OuterJoin<Col> {
   /** Node type discriminator */
-  readonly type: 'outer';
+  readonly type: "outer";
 
   /** Primes the join operation. Left part of LEFT JOIN. */
   readonly primary: JoinEntry<Col>;
@@ -142,12 +142,12 @@ export interface FullPTableColumnData {
 
 export interface SingleValueIsNAPredicate {
   /** Comparison operator */
-  readonly operator: 'IsNA';
+  readonly operator: "IsNA";
 }
 
 export interface SingleValueEqualPredicate {
   /** Comparison operator */
-  readonly operator: 'Equal';
+  readonly operator: "Equal";
 
   /** Reference value, NA values will not match */
   readonly reference: string | number;
@@ -155,7 +155,7 @@ export interface SingleValueEqualPredicate {
 
 export interface SingleValueInSetPredicate {
   /** Comparison operator */
-  readonly operator: 'InSet';
+  readonly operator: "InSet";
 
   /** Reference values, NA values will not match */
   readonly references: (string | number)[];
@@ -163,7 +163,7 @@ export interface SingleValueInSetPredicate {
 
 export interface SingleValueIEqualPredicate {
   /** Comparison operator (case insensitive) */
-  readonly operator: 'IEqual';
+  readonly operator: "IEqual";
 
   /** Reference value, NA values will not match */
   readonly reference: string;
@@ -171,7 +171,7 @@ export interface SingleValueIEqualPredicate {
 
 export interface SingleValueLessPredicate {
   /** Comparison operator */
-  readonly operator: 'Less';
+  readonly operator: "Less";
 
   /** Reference value, NA values will not match */
   readonly reference: string | number;
@@ -179,7 +179,7 @@ export interface SingleValueLessPredicate {
 
 export interface SingleValueLessOrEqualPredicate {
   /** Comparison operator */
-  readonly operator: 'LessOrEqual';
+  readonly operator: "LessOrEqual";
 
   /** Reference value, NA values will not match */
   readonly reference: string | number;
@@ -187,7 +187,7 @@ export interface SingleValueLessOrEqualPredicate {
 
 export interface SingleValueGreaterPredicate {
   /** Comparison operator */
-  readonly operator: 'Greater';
+  readonly operator: "Greater";
 
   /** Reference value, NA values will not match */
   readonly reference: string | number;
@@ -195,7 +195,7 @@ export interface SingleValueGreaterPredicate {
 
 export interface SingleValueGreaterOrEqualPredicate {
   /** Comparison operator */
-  readonly operator: 'GreaterOrEqual';
+  readonly operator: "GreaterOrEqual";
 
   /** Reference value, NA values will not match */
   readonly reference: string | number;
@@ -203,7 +203,7 @@ export interface SingleValueGreaterOrEqualPredicate {
 
 export interface SingleValueStringContainsPredicate {
   /** Comparison operator */
-  readonly operator: 'StringContains';
+  readonly operator: "StringContains";
 
   /** Reference substring, NA values are skipped */
   readonly substring: string;
@@ -211,7 +211,7 @@ export interface SingleValueStringContainsPredicate {
 
 export interface SingleValueStringIContainsPredicate {
   /** Comparison operator (case insensitive) */
-  readonly operator: 'StringIContains';
+  readonly operator: "StringIContains";
 
   /** Reference substring, NA values are skipped */
   readonly substring: string;
@@ -219,7 +219,7 @@ export interface SingleValueStringIContainsPredicate {
 
 export interface SingleValueMatchesPredicate {
   /** Comparison operator */
-  readonly operator: 'Matches';
+  readonly operator: "Matches";
 
   /** Regular expression, NA values are skipped */
   readonly regex: string;
@@ -227,7 +227,7 @@ export interface SingleValueMatchesPredicate {
 
 export interface SingleValueStringContainsFuzzyPredicate {
   /** Comparison operator */
-  readonly operator: 'StringContainsFuzzy';
+  readonly operator: "StringContainsFuzzy";
 
   /** Reference value, NA values are skipped */
   readonly reference: string;
@@ -256,7 +256,7 @@ export interface SingleValueStringContainsFuzzyPredicate {
 
 export interface SingleValueStringIContainsFuzzyPredicate {
   /** Comparison operator (case insensitive) */
-  readonly operator: 'StringIContainsFuzzy';
+  readonly operator: "StringIContainsFuzzy";
 
   /** Reference value, NA values are skipped */
   readonly reference: string;
@@ -285,7 +285,7 @@ export interface SingleValueStringIContainsFuzzyPredicate {
 
 export interface SingleValueNotPredicateV2 {
   /** Comparison operator */
-  readonly operator: 'Not';
+  readonly operator: "Not";
 
   /** Operand to negate */
   readonly operand: SingleValuePredicateV2;
@@ -293,7 +293,7 @@ export interface SingleValueNotPredicateV2 {
 
 export interface SingleValueAndPredicateV2 {
   /** Comparison operator */
-  readonly operator: 'And';
+  readonly operator: "And";
 
   /** Operands to combine */
   readonly operands: SingleValuePredicateV2[];
@@ -301,7 +301,7 @@ export interface SingleValueAndPredicateV2 {
 
 export interface SingleValueOrPredicateV2 {
   /** Comparison operator */
-  readonly operator: 'Or';
+  readonly operator: "Or";
 
   /** Operands to combine */
   readonly operands: SingleValuePredicateV2[];
@@ -334,7 +334,7 @@ export type SingleValuePredicateV2 =
  * */
 export interface PTableRecordSingleValueFilterV2 {
   /** Filter type discriminator */
-  readonly type: 'bySingleColumnV2';
+  readonly type: "bySingleColumnV2";
 
   /** Target axis selector to examine values from */
   readonly column: PTableColumnId;
@@ -388,48 +388,42 @@ export type CalculateTableDataRequest<Col> = {
 /** Response for {@link CalculateTableDataRequest} */
 export type CalculateTableDataResponse = FullPTableColumnData[];
 
-export function mapPTableDef<C1, C2>(
-  def: PTableDef<C1>,
-  cb: (c: C1) => C2,
-): PTableDef<C2> {
+export function mapPTableDef<C1, C2>(def: PTableDef<C1>, 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,
-): JoinEntry<C2> {
+export function mapJoinEntry<C1, C2>(entry: JoinEntry<C1>, cb: (c: C1) => C2): JoinEntry<C2> {
   switch (entry.type) {
-    case 'column':
+    case "column":
       return {
-        type: 'column',
+        type: "column",
         column: cb(entry.column),
       };
-    case 'slicedColumn':
+    case "slicedColumn":
       return {
-        type: 'slicedColumn',
+        type: "slicedColumn",
         column: cb(entry.column),
         newId: entry.newId,
         axisFilters: entry.axisFilters,
       };
-    case 'artificialColumn':
+    case "artificialColumn":
       return {
-        type: 'artificialColumn',
+        type: "artificialColumn",
         column: cb(entry.column),
         newId: entry.newId,
         axesIndices: entry.axesIndices,
       };
-    case 'inlineColumn':
+    case "inlineColumn":
       return entry;
-    case 'inner':
-    case 'full':
+    case "inner":
+    case "full":
       return {
         type: entry.type,
         entries: entry.entries.map((col) => mapJoinEntry(col, cb)),
       };
-    case 'outer':
+    case "outer":
       return {
-        type: 'outer',
+        type: "outer",
         primary: mapJoinEntry(entry.primary, cb),
         secondary: entry.secondary.map((col) => mapJoinEntry(col, cb)),
       };

package/src/drivers/pframe/table_common.ts

@@ -1,14 +1,14 @@
-import type { PObjectId } from '../../pool';
-import type { AxisId, AxisSpec, PColumnSpec } from './spec/spec';
+import type { PObjectId } from "../../pool";
+import type { AxisId, AxisSpec, PColumnSpec } from "./spec/spec";
 
 export type PTableColumnSpecAxis = {
-  type: 'axis';
+  type: "axis";
   id: AxisId;
   spec: AxisSpec;
 };
 
 export type PTableColumnSpecColumn = {
-  type: 'column';
+  type: "column";
   id: PObjectId;
   spec: PColumnSpec;
 };
@@ -17,12 +17,12 @@ export type PTableColumnSpecColumn = {
 export type PTableColumnSpec = PTableColumnSpecAxis | PTableColumnSpecColumn;
 
 export type PTableColumnIdAxis = {
-  type: 'axis';
+  type: "axis";
   id: AxisId;
 };
 
 export type PTableColumnIdColumn = {
-  type: 'column';
+  type: "column";
   id: PObjectId;
 };
 
@@ -31,14 +31,14 @@ export type PTableColumnId = PTableColumnIdAxis | PTableColumnIdColumn;
 
 export function getPTableColumnId(spec: PTableColumnSpec): PTableColumnId {
   switch (spec.type) {
-    case 'axis':
+    case "axis":
       return {
-        type: 'axis',
+        type: "axis",
         id: spec.id,
       };
-    case 'column':
+    case "column":
       return {
-        type: 'column',
+        type: "column",
         id: spec.id,
       };
   }

package/src/drivers/pframe/type_util.ts

@@ -2,14 +2,9 @@
 export type AddParameters<
   TParameters extends [...args: any],
   TFunction extends (...args: any) => any,
-> = (
-  ...args: [...TParameters, ...Parameters<TFunction>]
-) => ReturnType<TFunction>;
+> = (...args: [...TParameters, ...Parameters<TFunction>]) => ReturnType<TFunction>;
 
-export type AddParameterToAllMethods<
-  Interface,
-  TParameters extends [...args: any],
-> = {
+export type AddParameterToAllMethods<Interface, TParameters extends [...args: any]> = {
   [Field in keyof Interface]: Interface[Field] extends (...args: any) => any
     ? AddParameters<TParameters, Interface[Field]>
     : Interface[Field];

package/src/drivers/pframe/unique_values.ts

@@ -1,7 +1,7 @@
-import type { AxisId } from './spec/spec';
-import type { PTableRecordFilter } from './table_calculate';
-import type { PTableVector } from './data_types';
-import type { PObjectId } from '../../pool';
+import type { AxisId } from "./spec/spec";
+import type { PTableRecordFilter } from "./table_calculate";
+import type { PTableVector } from "./data_types";
+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/drivers/urls.ts

@@ -3,7 +3,7 @@
  */
 export type FolderURL = `plblob+folder://${string}`;
 
-export type ArchiveFormat = 'zip' | 'tar' | 'tgz';
+export type ArchiveFormat = "zip" | "tar" | "tgz";
 
 export interface BlobToURLDriver {
   getPathForCustomProtocol(url: FolderURL): string;
@@ -11,7 +11,7 @@ export interface BlobToURLDriver {
 
 export function isFolderURL(url: string): url is FolderURL {
   const parsed = new URL(url);
-  return parsed.protocol == 'plblob+folder:';
+  return parsed.protocol == "plblob+folder:";
 }
 
 /**
@@ -26,5 +26,5 @@ export interface FrontendDriver {
 
 export function isBlockUIURL(url: string): url is BlockUIURL {
   const parsed = new URL(url);
-  return parsed.protocol == 'block-ui:';
+  return parsed.protocol == "block-ui:";
 }

package/src/errors.test.ts

@@ -1,34 +1,34 @@
-import { describe, test, expect } from 'vitest';
+import { describe, test, expect } from "vitest";
 import {
   deserializeResult,
   unwrapResult,
   AbortError,
   hasAbortError,
   wrapAndSerializeAsync,
-} from './errors';
+} from "./errors";
 
-describe('Full error handling cycle example', () => {
-  test('should handle complete workflow: async callback -> serialize -> deserialize with nested AbortError', async () => {
-    const abortError = new AbortError('Operation was aborted');
-    const middleError = new Error('Middle layer failed', { cause: abortError });
-    const topError = new Error('Top level operation failed', { cause: middleError });
+describe("Full error handling cycle example", () => {
+  test("should handle complete workflow: async callback -> serialize -> deserialize with nested AbortError", async () => {
+    const abortError = new AbortError("Operation was aborted");
+    const middleError = new Error("Middle layer failed", { cause: abortError });
+    const topError = new Error("Top level operation failed", { cause: middleError });
 
     const serialized = await wrapAndSerializeAsync(async () => {
       throw topError;
     });
 
     expect(serialized.error).toBeDefined();
-    expect(serialized.error?.message).toBe('Top level operation failed');
-    expect(serialized.error?.cause?.message).toBe('Middle layer failed');
-    expect(serialized.error?.cause?.cause?.message).toBe('Operation was aborted');
-    expect(serialized.error?.cause?.cause?.name).toBe('AbortError');
+    expect(serialized.error?.message).toBe("Top level operation failed");
+    expect(serialized.error?.cause?.message).toBe("Middle layer failed");
+    expect(serialized.error?.cause?.cause?.message).toBe("Operation was aborted");
+    expect(serialized.error?.cause?.cause?.name).toBe("AbortError");
 
     const deserialized = deserializeResult(serialized);
     expect(deserialized.error).toBeInstanceOf(Error);
-    expect(deserialized.error?.message).toBe('Top level operation failed');
+    expect(deserialized.error?.message).toBe("Top level operation failed");
 
-    if (!deserialized.error) {  
-      throw new Error('Deserialized error is undefined');
+    if (!deserialized.error) {
+      throw new Error("Deserialized error is undefined");
     }
 
     const deserializedError = deserialized.error;
@@ -36,13 +36,13 @@ describe('Full error handling cycle example', () => {
     const abortCause = middleCause.cause as Error;
 
     expect(middleCause).toBeInstanceOf(Error);
-    expect(middleCause.message).toBe('Middle layer failed');
-    
+    expect(middleCause.message).toBe("Middle layer failed");
+
     expect(abortCause).toBeInstanceOf(Error);
-    expect(abortCause.message).toBe('Operation was aborted');
-    expect(abortCause.name).toBe('AbortError');
+    expect(abortCause.message).toBe("Operation was aborted");
+    expect(abortCause.name).toBe("AbortError");
 
-    expect(() => unwrapResult(deserialized)).toThrow('Top level operation failed');
+    expect(() => unwrapResult(deserialized)).toThrow("Top level operation failed");
     expect(hasAbortError(deserialized.error)).toBe(true);
   });
-});
+});

package/src/errors.ts

@@ -2,18 +2,18 @@
  * Just for convenience, usually it is an Error with name 'AbortError'
  */
 export class AbortError extends Error {
-  name = 'AbortError';
+  name = "AbortError";
 }
 
 /**
  * Throw this to show a message without stack trace in UI
  */
 export class UiError extends Error {
-  name = 'UiError';
+  name = "UiError";
 }
 
-export function isAbortError(error: unknown): error is Error & { name: 'AbortError' } {
-  return error instanceof Error && error.name === 'AbortError';
+export function isAbortError(error: unknown): error is Error & { name: "AbortError" } {
+  return error instanceof Error && error.name === "AbortError";
 }
 
 export function hasAbortError(error: unknown): boolean {
@@ -21,35 +21,35 @@ export function hasAbortError(error: unknown): boolean {
     return false;
   }
 
-  return error.name === 'AbortError' || hasAbortError(error.cause);
+  return error.name === "AbortError" || hasAbortError(error.cause);
 }
 
 export function isAggregateError(error: unknown): error is AggregateError {
-  return error instanceof Error && error.name === 'AggregateError';
+  return error instanceof Error && error.name === "AggregateError";
 }
 
 export class PFrameError extends Error {
-  name = 'PFrameError';
+  name = "PFrameError";
 }
 
 export function isPFrameError(error: unknown): error is PFrameError {
-  return error instanceof Error && error.name === 'PFrameError';
+  return error instanceof Error && error.name === "PFrameError";
 }
 
 export class PFrameDriverError extends PFrameError {
-  name = 'PFrameError.Driver';
+  name = "PFrameError.Driver";
 }
 
 export function isPFrameDriverError(error: unknown): error is PFrameDriverError {
-  return error instanceof Error && error.name === 'PFrameError.Driver';
+  return error instanceof Error && error.name === "PFrameError.Driver";
 }
 
 function stringifyValue(value: unknown): string {
-  if (typeof value === 'string') {
+  if (typeof value === "string") {
     return `String value was thrown: ${value}`;
   }
 
-  if (value && typeof value === 'object') {
+  if (value && typeof value === "object") {
     try {
       return `Plain object was thrown: ${JSON.stringify(value)}`;
     } catch (jsonError) {
@@ -82,7 +82,7 @@ export function deserializeError(obj: SerializedError): Error {
   const cause = obj.cause ? deserializeError(obj.cause) : undefined;
 
   const error = new Error(obj.message, cause !== undefined ? { cause } : undefined);
-  error.name = obj.name || 'Error';
+  error.name = obj.name || "Error";
   error.stack = obj.stack;
 
   return error;
@@ -100,12 +100,14 @@ export function serializeError(e: unknown): SerializedError {
   };
 }
 
-export type ResultOrError<S, F = Error> = {
-  value: S;
-  error?: undefined;
-} | {
-  error: F;
-};
+export type ResultOrError<S, F = Error> =
+  | {
+      value: S;
+      error?: undefined;
+    }
+  | {
+      error: F;
+    };
 
 export function unwrapResult<T>(result: ResultOrError<T, Error | SerializedError>): T {
   if (result.error) {
@@ -151,7 +153,9 @@ export function wrapAndSerialize<T>(callback: () => T): ResultOrError<T, Seriali
   return serializeResult(result);
 }
 
-export async function wrapAndSerializeAsync<T>(callback: () => Promise<T>): Promise<ResultOrError<T, SerializedError>> {
+export async function wrapAndSerializeAsync<T>(
+  callback: () => Promise<T>,
+): Promise<ResultOrError<T, SerializedError>> {
   const result = await wrapAsyncCallback(callback);
   return serializeResult(result);
 }

package/src/flags/block_flags.ts

@@ -1,4 +1,4 @@
-import type { ArrayTypeUnion, Assert, Is, IsSubtypeOf } from './type_utils';
+import type { ArrayTypeUnion, Assert, Is, IsSubtypeOf } from "./type_utils";
 
 /**
  * Block-specific feature flags. Define flags that are interpreted by the desktop app to select
@@ -8,7 +8,8 @@ import type { ArrayTypeUnion, Assert, Is, IsSubtypeOf } from './type_utils';
  *   - supports... - those flags tells the desktop app that the block supports certain APIs, but can without them as well
  *   - requires... - those flags tells the desktop app that the block requires certain APIs, and if desktop app doesn't support it, it can't be used in the block
  */
-export type BlockCodeFeatureFlags = Record<`supports${string}`, boolean | number | undefined> & Record<`requires${string}`, boolean | number | undefined>;
+export type BlockCodeFeatureFlags = Record<`supports${string}`, boolean | number | undefined> &
+  Record<`requires${string}`, boolean | number | undefined>;
 
 /**
  * Known block flags. Flags are set during model compilation, see `BlockModel.create` for more details and for initial values.
@@ -19,11 +20,9 @@ export type BlockCodeKnownFeatureFlags = {
   readonly requiresUIAPIVersion?: number;
 };
 
-export const AllSupportsFeatureFlags
-  = ['supportsLazyState'] as const;
+export const AllSupportsFeatureFlags = ["supportsLazyState"] as const;
 
-export const AllRequiresFeatureFlags
-  = ['requiresUIAPIVersion', 'requiresModelAPIVersion'] as const;
+export const AllRequiresFeatureFlags = ["requiresUIAPIVersion", "requiresModelAPIVersion"] as const;
 
 //
 // Assertions
@@ -31,7 +30,9 @@ export const AllRequiresFeatureFlags
 
 // This assertion ensures that BlockConfigV3KnownFeatureFlags is a subtype of BlockConfigV3FeatureFlags.
 // It will produce a compile-time error if there's a mismatch.
-type _KnownFlagsAreValidFlags = Assert<IsSubtypeOf<BlockCodeKnownFeatureFlags, BlockCodeFeatureFlags>>;
+type _KnownFlagsAreValidFlags = Assert<
+  IsSubtypeOf<BlockCodeKnownFeatureFlags, BlockCodeFeatureFlags>
+>;
 
 // This check ensures that all keys in BlockConfigV3FeatureFlags are covered in the arrays above.
 // It will produce a compile-time error if there's a mismatch.