@dxos/compute 0.8.4-main.fcfe5033a5 → 0.8.4-staging.60fe92afc8

package/src/functions/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './async-function';
-export * from './edge-function';
-export * from './function-defs';

package/src/hyperformula.test.ts

@@ -1,14 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { describe, expect, test } from 'vitest';
-
-import { HyperFormula } from '@dxos/vendor-hyperformula';
-
-describe('hyperformula', () => {
-  test('sanity test', async () => {
-    const hf = HyperFormula.buildEmpty({ licenseKey: 'gpl-v3' });
-    expect(hf).to.exist;
-  });
-});

package/src/testing/test-builder.ts

@@ -1,59 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Client, type ClientOptions } from '@dxos/client';
-import { type Context, Resource } from '@dxos/context';
-import { invariant } from '@dxos/invariant';
-
-import { type ComputeGraphOptions, ComputeGraphRegistry } from '../compute-graph-registry';
-import { createMockedComputeRuntimeProvider } from './test-runtime';
-
-export type TestBuilderOptions = ClientOptions & Partial<ComputeGraphOptions>;
-
-// TODO(burdon): Reconcile with @dxos/client/testing.
-export class TestBuilder extends Resource {
-  private _client?: Client;
-  private _registry?: ComputeGraphRegistry;
-
-  constructor(private readonly _options: TestBuilderOptions = {}) {
-    super();
-  }
-
-  get ctx(): Context {
-    return this._ctx;
-  }
-
-  get client(): Client {
-    invariant(this._client);
-    return this._client;
-  }
-
-  get registry(): ComputeGraphRegistry {
-    invariant(this._registry);
-    return this._registry;
-  }
-
-  override async _open(): Promise<void> {
-    const client = new Client(this._options);
-    await client.initialize();
-    await client.halo.createIdentity();
-    this._client = client;
-    this._ctx.onDispose(async () => {
-      await client.destroy();
-      this._client = undefined;
-    });
-
-    const registry = new ComputeGraphRegistry({
-      ...this._options,
-      // Provide a default runtime provider for tests if not supplied.
-      computeRuntime: this._options.computeRuntime ?? createMockedComputeRuntimeProvider(),
-    });
-    await registry.open();
-    this._registry = registry;
-    this._ctx.onDispose(async () => {
-      await registry.close();
-      this._registry = undefined;
-    });
-  }
-}

package/src/testing/test-plugin.ts

@@ -1,98 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getDeep } from '@dxos/util';
-import { type InterpreterState, type ProcedureAst } from '@dxos/vendor-hyperformula';
-import { FunctionArgumentType } from '@dxos/vendor-hyperformula';
-
-import { type ComputeGraphPlugin } from '../compute-graph-registry';
-import { type AsyncFunction, AsyncFunctionPlugin } from '../functions';
-import { parseNumberString } from '../util';
-
-/**
- * Testing functions run locally (not run via EDGE).
- * https://hyperformula.handsontable.com/guide/custom-functions.html#add-a-simple-custom-function
- */
-export class TestPlugin extends AsyncFunctionPlugin {
-  /**
-   * Simple local function returns input value.
-   */
-  test(ast: ProcedureAst, state: InterpreterState) {
-    const handler: AsyncFunction = async (_value) => {
-      return _value;
-    };
-
-    return this.runAsyncFunction(ast, state, handler);
-  }
-
-  /**
-   * Simple local function returns random number.
-   */
-  random(ast: ProcedureAst, state: InterpreterState) {
-    const handler: AsyncFunction = async () => {
-      return Math.random();
-    };
-
-    return this.runAsyncFunction(ast, state, handler);
-  }
-
-  /**
-   * Async HTTP function.
-   */
-  crypto(ast: ProcedureAst, state: InterpreterState) {
-    const handler: AsyncFunction = async (_currency) => {
-      const currency = (_currency || 'USD').toUpperCase();
-      const result = await fetch(`https://api.coindesk.com/v1/bpi/currentprice/${currency}.json`);
-      const data = await result.json();
-      const rate = getDeep<string>(data, ['bpi', currency, 'rate']);
-      if (!rate) {
-        return NaN;
-      }
-
-      return parseNumberString(rate);
-    };
-
-    return this.runAsyncFunction(ast, state, handler, { ttl: 10_000 });
-  }
-}
-
-TestPlugin.implementedFunctions = {
-  TEST: {
-    method: 'test',
-    parameters: [{ argumentType: FunctionArgumentType.NUMBER, optionalArg: false }],
-    isVolatile: true,
-  },
-
-  RANDOM: {
-    method: 'random',
-    parameters: [],
-    isVolatile: true,
-  },
-
-  CRYPTO: {
-    method: 'crypto',
-    parameters: [{ argumentType: FunctionArgumentType.STRING, optionalArg: true }],
-    isVolatile: true,
-  },
-};
-
-export const TestPluginTranslations = {
-  enGB: {
-    TEST: 'Returns input value',
-    RANDOM: 'Random number',
-    CRYPTO: 'Crypto token value',
-  },
-  enUS: {
-    TEST: 'Returns input value',
-    RANDOM: 'Random number',
-    CRYPTO: 'Crypto token value',
-  },
-};
-
-export const testFunctionPlugins: ComputeGraphPlugin[] = [
-  {
-    plugin: TestPlugin,
-    translations: TestPluginTranslations,
-  },
-];

package/src/testing/test-runtime.ts

@@ -1,53 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as ManagedRuntime from 'effect/ManagedRuntime';
-
-import { type SpaceId } from '@dxos/client/echo';
-import { Operation, OperationHandlerSet } from '@dxos/operation';
-
-import { type FunctionsRuntimeProvider } from '../compute-graph-registry';
-
-/**
- * Minimal compute runtime provider for tests and Storybook.
- * Will cause errors if used for actual runtime.
- */
-export const createMockedComputeRuntimeProvider = ({
-  functions,
-}: { functions?: OperationHandlerSet.OperationHandlerSet } = {}): FunctionsRuntimeProvider => {
-  return {
-    getRuntime: (_spaceId: SpaceId) =>
-      ManagedRuntime.make(
-        functions
-          ? Layer.effect(
-              Operation.Service,
-              Effect.gen(function* () {
-                const handlers = yield* functions.handlers;
-                return {
-                  invoke: (op: any, ...args: any[]) => {
-                    const handler = handlers.find((h: any) => h.meta.key === op.meta.key);
-                    if (!handler) {
-                      return Effect.die(`No handler found for operation: ${op.meta.key}`);
-                    }
-                    const result = handler.handler(args[0]);
-                    if (Effect.isEffect(result)) {
-                      return result as Effect.Effect<unknown>;
-                    }
-                    return Effect.promise(() => Promise.resolve(result));
-                  },
-                  schedule: () => Effect.void,
-                  invokePromise: async () => ({ error: new Error('Not implemented in test runtime') }),
-                } as Operation.OperationService;
-              }),
-            )
-          : Layer.succeed(Operation.Service, {
-              invoke: () => Effect.die('Operation.Service not available in test.'),
-              schedule: () => Effect.die('Operation.Service not available in test.'),
-              invokePromise: async () => ({ error: new Error('Not available') }),
-            } as any),
-      ),
-  };
-};

package/src/testing/util.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { HyperFormula } from '@dxos/vendor-hyperformula';
-
-export const getRegisteredFunctionNames = () => {
-  return HyperFormula.buildEmpty({ licenseKey: 'gpl-v3' }).getRegisteredFunctionNames();
-};

package/src/types/hyperformula.ts

@@ -1,19 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import {
-  type SimpleCellAddress,
-  type SimpleCellRange,
-  type SimpleDate,
-  type SimpleDateTime,
-} from '@dxos/vendor-hyperformula';
-import { DetailedCellError, ExportedCellChange } from '@dxos/vendor-hyperformula';
-
-/**
- * Re-exported from vendored hyperformula package.
- */
-
-export { DetailedCellError, ExportedCellChange };
-
-export type { SimpleCellRange, SimpleCellAddress, SimpleDate, SimpleDateTime };

package/src/types/index.ts

@@ -1,6 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-export * from './hyperformula';
-export * from './types';

package/src/types/types.test.ts

@@ -1,91 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { getIndices, getIndicesAbove, getIndicesBelow, getIndicesBetween, sortByIndex } from '@tldraw/indices';
-import { describe, expect, test } from 'vitest';
-
-import { addressFromA1Notation, addressToA1Notation, inRange, rangeFromA1Notation, rangeToA1Notation } from './types';
-
-describe('cell', () => {
-  test('posToA1Notation', () => {
-    expect(addressToA1Notation({ col: 0, row: 0 })).to.eq('A1');
-    expect(addressFromA1Notation('C2')).to.deep.eq({ col: 2, row: 1 });
-  });
-
-  test('rangeToA1Notation', () => {
-    expect(rangeToA1Notation({ from: addressFromA1Notation('A1'), to: addressFromA1Notation('A5') })).to.eq('A1:A5');
-  });
-
-  test('inRange', () => {
-    const range = rangeFromA1Notation('A1:C5');
-    expect(inRange(range, addressFromA1Notation('A1'))).to.be.true;
-    expect(inRange(range, addressFromA1Notation('C5'))).to.be.true;
-    expect(inRange(range, addressFromA1Notation('A6'))).to.be.false;
-    expect(inRange(range, addressFromA1Notation('D5'))).to.be.false;
-  });
-
-  // TODO(burdon): Move to model.test.ts
-  test('index', () => {
-    // Pre-allocated grid.
-    const n = 5;
-    const columns = getIndices(n - 1);
-    const rows = getIndices(n - 1);
-
-    const pickOne = (indices: string[]) => indices[Math.floor(Math.random() * indices.length)];
-
-    /**
-     * Insert an index into the allocated list.
-     * Randomly picks from n values between indexes to support probabilistic concurrency.
-     */
-    const insertIndex = (indices: string[], i: number, n = 20) => {
-      if (i === 0) {
-        const idx = pickOne(getIndicesBelow(indices[0], n));
-        indices.splice(0, 0, idx);
-      } else if (i >= indices.length) {
-        // Reallocate if > current bounds.
-        // TODO(burdon): Is this OK if this happens concurrently?
-        indices.splice(indices.length, 0, ...getIndicesAbove(indices[indices.length - 1], i + 1 - indices.length));
-      } else {
-        const idx = pickOne(getIndicesBetween(indices[i - 1], indices[i], n));
-        indices.splice(i, 0, idx);
-      }
-    };
-
-    // Values.
-    const cells: Record<string, any> = {};
-    const setCell = (cell: string, value: any) => {
-      const { col, row } = addressFromA1Notation(cell);
-      // Reallocate if > current bounds.
-      if (col >= columns.length) {
-        insertIndex(columns, col);
-      }
-      if (row >= rows.length) {
-        insertIndex(rows, row);
-      }
-      const index = `${columns[col]}@${rows[row]}`;
-      cells[index] = value;
-    };
-
-    expect(addressFromA1Notation('A1')).to.deep.eq({ col: 0, row: 0 });
-
-    expect(columns).to.deep.eq(['a1', 'a2', 'a3', 'a4', 'a5']);
-    insertIndex(columns, 7);
-    expect(columns).to.deep.eq(['a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8']);
-
-    setCell('A1', 100);
-    setCell('B1', 101);
-
-    insertIndex(columns, 1);
-    setCell('B1', 102);
-
-    setCell('J10', 104);
-    expect(columns).to.have.length(10);
-    expect(rows).to.have.length(10);
-
-    const entries = Object.entries(cells).map(([key, value]) => ({ index: key.split('@')[0], value }));
-    const sorted = entries.sort(sortByIndex);
-    const values = sorted.map(({ value }) => value);
-    expect(values).to.deep.eq([100, 102, 101, 104]);
-  });
-});

package/src/types/types.ts

@@ -1,80 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { invariant } from '@dxos/invariant';
-
-// TODO(burdon): Reconcile with DxGridPlanePosition.
-export type CellAddress = Record<'row' | 'col', number>;
-// TODO(burdon): Unify and use Partial<CellRange> as needed.
-export type CellRange = { from: CellAddress; to?: CellAddress };
-export type CompleteCellRange = { from: CellAddress; to: CellAddress };
-
-export type CellScalarValue = number | string | boolean | null;
-
-export const RANGE_NOTATION = /^[A-Z]+[0-9]+(:[A-Z]+[0-9]+)?$/;
-
-export const isFormula = (value: any): value is string => typeof value === 'string' && value.charAt(0) === '=';
-
-export const cellEquals = (a: CellAddress | undefined, b: CellAddress | undefined) => {
-  return a?.col === b?.col && a?.row === b?.row;
-};
-
-export const columnLetter = (col: number): string => {
-  invariant(col < 676, `Invalid column: ${col}`); // 26^2
-  return (
-    (col >= 26 ? String.fromCharCode('A'.charCodeAt(0) + Math.floor(col / 26) - 1) : '') +
-    String.fromCharCode('A'.charCodeAt(0) + (col % 26))
-  );
-};
-
-export const addressToA1Notation = ({ col, row }: CellAddress): string => {
-  return `${columnLetter(col)}${row + 1}`;
-};
-
-// TODO(burdon): See (HF) simpleCellAddressFromString.
-export const addressFromA1Notation = (ref: string): CellAddress => {
-  const match = ref.match(/([A-Z]+)(\d+)/);
-  invariant(match, `Invalid notation: ${ref}`);
-  return {
-    row: parseInt(match[2], 10) - 1,
-    col: match[1].split('').reduce((acc, c) => acc * 26 + c.charCodeAt(0) - 'A'.charCodeAt(0) + 1, 0) - 1,
-  };
-};
-
-export const rangeToA1Notation = (range: CellRange) => {
-  return [range?.from && addressToA1Notation(range?.from), range?.to && addressToA1Notation(range?.to)]
-    .filter(Boolean)
-    .join(':');
-};
-
-export const rangeFromA1Notation = (ref: string): CellRange => {
-  const [from, to] = ref.split(':').map(addressFromA1Notation);
-  return { from, to };
-};
-
-export const inRange = (range: CellRange | undefined, cell: CellAddress): boolean => {
-  if (!range) {
-    return false;
-  }
-
-  const { from, to } = range;
-  if ((from && cellEquals(from, cell)) || (to && cellEquals(to, cell))) {
-    return true;
-  }
-
-  if (!from || !to) {
-    return false;
-  }
-
-  const { col: c1, row: r1 } = from;
-  const { col: c2, row: r2 } = to;
-
-  const cMin = Math.min(c1, c2);
-  const cMax = Math.max(c1, c2);
-  const rMin = Math.min(r1, r2);
-  const rMax = Math.max(r1, r2);
-
-  const { col, row } = cell;
-  return col >= cMin && col <= cMax && row >= rMin && row <= rMax;
-};

package/src/util.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-// TODO(burdon): Factor out.
-export const parseNumberString = (str: string): number => {
-  return parseFloat(str.replace(/[^\d.]/g, ''));
-};