@nordcraft/core 1.0.94 → 1.0.96

package/src/formula/formulaUtils.ts

@@ -11,7 +11,7 @@ import { isFormula, isToddleFormula } from './formula'
 import type { GlobalFormulas } from './formulaTypes'
 
 export const valueFormula = (
-  value: string | number | boolean | null | object,
+  value: string | number | boolean | null | object | undefined,
 ): ValueOperation => ({
   type: 'value',
   value,
@@ -67,7 +67,7 @@ export function* getFormulasInFormula<Handler>({
     case 'value':
       break
     case 'record':
-      for (const [key, entry] of formula.entries.entries()) {
+      for (const [key, entry] of (formula.entries ?? []).entries()) {
         yield* getFormulasInFormula({
           formula: entry.formula,
           globalFormulas,
@@ -148,7 +148,7 @@ export function* getFormulasInFormula<Handler>({
       }
       break
     case 'switch':
-      for (const [key, c] of formula.cases.entries()) {
+      for (const [key, c] of formula.cases?.entries() ?? []) {
         yield* getFormulasInFormula({
           formula: c.condition,
           globalFormulas,

package/src/formula/functionFormula.test.ts

@@ -0,0 +1,89 @@
+import { describe, expect, it } from 'bun:test'
+import type { FormulaHandlerV2 } from '../types'
+import type { FunctionOperation } from './formula'
+import type { PluginFormula } from './formulaTypes'
+import { valueFormula } from './formulaUtils'
+import { applyFunctionFormula } from './functionFormula'
+import { createTestFormulaContext } from './testUtils.test'
+
+const contextWithCustomFormulas = (
+  formulas: Record<string, PluginFormula<FormulaHandlerV2>>,
+) => {
+  return {
+    ...createTestFormulaContext(),
+    toddle: {
+      ...createTestFormulaContext().toddle,
+      getCustomFormula: (name: string) => formulas[name],
+    },
+  }
+}
+
+describe('applyFunctionFormula', () => {
+  it('returns the value of a simple function formula', () => {
+    const ctx = contextWithCustomFormulas({
+      identity: {
+        version: 2,
+        name: 'identity',
+        handler: () => 42,
+        arguments: [],
+      },
+    })
+    expect(
+      applyFunctionFormula(
+        { type: 'function', name: 'identity', arguments: [] },
+        ctx,
+      ),
+    ).toBe(42)
+  })
+
+  it('returns null if the function is not found', () => {
+    const formula: FunctionOperation = {
+      type: 'function',
+      name: 'missing',
+      arguments: [{ name: 'x', formula: valueFormula(1) }],
+    }
+    const ctx = contextWithCustomFormulas({})
+    expect(applyFunctionFormula(formula, ctx)).toBeNull()
+  })
+
+  it('calls isFunction arguments as functions', () => {
+    const formula: FunctionOperation = {
+      type: 'function',
+      name: 'fn',
+      arguments: [
+        {
+          name: 'fn',
+          isFunction: true,
+          formula: valueFormula('called'),
+        },
+      ],
+    }
+    const ctx = contextWithCustomFormulas({
+      fn: {
+        version: 2,
+        name: 'fn',
+        handler: ({ fn }) => {
+          return (fn as any)()
+        },
+        arguments: [{ name: 'fn' }],
+      },
+    })
+    expect(applyFunctionFormula(formula, ctx)).toBe('called')
+  })
+
+  it('returns the result of a ToddleFormula', () => {
+    const formula: FunctionOperation = {
+      type: 'function',
+      name: 'projectFormula',
+      arguments: [],
+    }
+    const ctx = contextWithCustomFormulas({
+      projectFormula: {
+        name: 'projectFormula',
+        arguments: [],
+        formula: valueFormula([1, 2, 3]),
+      },
+    })
+    expect(applyFunctionFormula(formula, ctx)).toEqual([1, 2, 3])
+  })
+})

package/src/formula/functionFormula.ts

@@ -0,0 +1,118 @@
+/* eslint-disable no-console */
+import type { FormulaHandler, Toddle } from '../types'
+import { measure } from '../utils/measure'
+import { isDefined } from '../utils/util'
+import {
+  applyFormula,
+  isToddleFormula,
+  type FormulaContext,
+  type FunctionOperation,
+} from './formula'
+
+export const applyFunctionFormula = (
+  formula: FunctionOperation,
+  ctx: FormulaContext,
+) => {
+  const stopMeasure = measure(`Formula: ${formula.name}`, {
+    formula,
+    component: ctx.component?.name,
+  })
+  const packageName = formula.package ?? ctx.package ?? undefined
+  const newFunc = (
+    ctx.toddle ??
+    ((globalThis as any).toddle as Toddle<unknown, unknown> | undefined)
+  )?.getCustomFormula(formula.name, packageName)
+  if (isDefined(newFunc)) {
+    ctx.package = packageName
+    const args = (formula.arguments ?? []).reduce<Record<string, unknown>>(
+      (args, arg, i) => ({
+        ...args,
+        [arg.name ?? `${i}`]: arg.isFunction
+          ? (Args: any) =>
+              applyFormula(
+                arg.formula,
+                {
+                  ...ctx,
+                  data: {
+                    ...ctx.data,
+                    Args: ctx.data.Args
+                      ? { ...Args, '@toddle.parent': ctx.data.Args }
+                      : Args,
+                  },
+                },
+                ['arguments', i],
+              )
+          : applyFormula(arg.formula, ctx, ['arguments', i]),
+      }),
+      {},
+    )
+    try {
+      if (isToddleFormula(newFunc)) {
+        return applyFormula(
+          newFunc.formula,
+          {
+            ...ctx,
+            data: { ...ctx.data, Args: args },
+          },
+          ['formula'],
+        )
+      } else {
+        return newFunc.handler(args, {
+          root: ctx.root ?? document,
+          env: ctx.env,
+        } as any)
+      }
+    } catch (e) {
+      ctx.toddle.errors.push(e as Error)
+      if (ctx.env?.logErrors) {
+        console.error(e)
+      }
+      return null
+    } finally {
+      stopMeasure()
+    }
+  } else {
+    // Lookup legacy formula
+    const legacyFunc: FormulaHandler | undefined = (
+      ctx.toddle ?? ((globalThis as any).toddle as Toddle<unknown, unknown>)
+    ).getFormula(formula.name)
+    if (typeof legacyFunc === 'function') {
+      const args = (formula.arguments ?? []).map((arg, i) =>
+        arg.isFunction
+          ? (Args: any) =>
+              applyFormula(
+                arg.formula,
+                {
+                  ...ctx,
+                  data: {
+                    ...ctx.data,
+                    Args: ctx.data.Args
+                      ? { ...Args, '@toddle.parent': ctx.data.Args }
+                      : Args,
+                  },
+                },
+                ['arguments', i],
+              )
+          : applyFormula(arg.formula, ctx, ['arguments', i]),
+      )
+      try {
+        return legacyFunc(args, ctx as any)
+      } catch (e) {
+        ctx.toddle.errors.push(e as Error)
+        if (ctx.env?.logErrors) {
+          console.error(e)
+        }
+        return null
+      } finally {
+        stopMeasure()
+      }
+    }
+  }
+  if (ctx.env?.logErrors) {
+    console.error(
+      `Could not find formula ${formula.name} in package ${packageName ?? ''}`,
+      formula,
+    )
+  }
+  return null
+}

package/src/formula/objectFormula.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test'
+import type { ObjectOperation } from './formula'
+import { valueFormula } from './formulaUtils'
+import { applyObjectFormula } from './objectFormula'
+import {
+  createTestFormulaContext,
+  createTestFormulaContextForAllPaths,
+} from './testUtils.test'
+
+describe('applyObjectFormula', () => {
+  it('returns an object with evaluated values', () => {
+    const formula: ObjectOperation = {
+      type: 'object',
+      arguments: [
+        { name: 'a', formula: valueFormula(1) },
+        { name: 'b', formula: valueFormula('hello') },
+        { name: 'c', formula: valueFormula(true) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyObjectFormula(formula, ctx)).toEqual({
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('returns an empty object if arguments is undefined', () => {
+    const formula: ObjectOperation = {
+      type: 'object',
+      arguments: undefined,
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyObjectFormula(formula, ctx)).toEqual({})
+  })
+
+  it('evaluates all formulas and reports results in "report" mode', () => {
+    const formula: ObjectOperation = {
+      type: 'object',
+      arguments: [
+        { name: 'x', formula: valueFormula('foo') },
+        { name: 'y', formula: valueFormula('bar') },
+      ],
+    }
+    const results: Record<string, any> = {}
+    const ctx = createTestFormulaContextForAllPaths(
+      {},
+      (path, result) => (results[path.join('/')] = result),
+    )
+    expect(applyObjectFormula(formula, ctx)).toEqual({ x: 'foo', y: 'bar' })
+    expect(results).toMatchObject({
+      'arguments/0/formula': 'foo',
+      'arguments/1/formula': 'bar',
+    })
+  })
+})

package/src/formula/objectFormula.ts

@@ -0,0 +1,17 @@
+import {
+  applyFormula,
+  type FormulaContext,
+  type ObjectOperation,
+} from './formula'
+
+export const applyObjectFormula = (
+  formula: ObjectOperation,
+  ctx: FormulaContext,
+) => {
+  return Object.fromEntries(
+    formula.arguments?.map((entry, i) => [
+      entry.name,
+      applyFormula(entry.formula, ctx, ['arguments', i, 'formula']),
+    ]) ?? [],
+  )
+}

package/src/formula/orFormula.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from 'bun:test'
+import { applyFormula, type OrOperation } from './formula'
+import { valueFormula } from './formulaUtils'
+import { applyEvaluateAllOrFormula, applyOrFormula } from './orFormula'
+import {
+  createTestFormulaContext,
+  createTestFormulaContextForAllPaths,
+} from './testUtils.test'
+
+describe('applyOrFormula', () => {
+  it('returns true if any argument is truthy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(0) },
+        { formula: valueFormula('yes') },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyOrFormula(formula, ctx)).toBe(true)
+  })
+
+  it('returns false if all arguments are falsy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(null) },
+        { formula: valueFormula(undefined) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyOrFormula(formula, ctx)).toBe(false)
+  })
+
+  it('returns true for first truthy argument', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(true) },
+        { formula: valueFormula(false) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyOrFormula(formula, ctx)).toBe(true)
+  })
+})
+
+describe('applyEvaluateAllOrFormula', () => {
+  it('visits all formulas in "report" mode even if the first argument is truthy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(true) },
+        { formula: valueFormula('hello') },
+        { formula: valueFormula(false) },
+      ],
+    }
+    const results: Record<string, any> = {}
+    const ctx = createTestFormulaContextForAllPaths(
+      {},
+      (path, result) => (results[path.join('/')] = result),
+    )
+    // Call applyFormula directly since it will report the results
+    expect(applyFormula(formula, ctx, [])).toBe(true)
+    expect(results).toMatchObject({
+      'arguments/0/formula': true,
+      'arguments/1/formula': 'hello',
+      'arguments/2/formula': false,
+    })
+  })
+
+  it('returns true if any argument is truthy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(1) },
+        { formula: valueFormula(false) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyEvaluateAllOrFormula(formula, ctx)).toBe(true)
+  })
+
+  it('returns false if all arguments are falsy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(null) },
+        { formula: valueFormula(undefined) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyEvaluateAllOrFormula(formula, ctx)).toBe(false)
+  })
+
+  it('returns true if last argument is truthy', () => {
+    const formula: OrOperation = {
+      type: 'or',
+      arguments: [
+        { formula: valueFormula(false) },
+        { formula: valueFormula(false) },
+        { formula: valueFormula('ok') },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyEvaluateAllOrFormula(formula, ctx)).toBe(true)
+  })
+})

package/src/formula/orFormula.ts

@@ -0,0 +1,33 @@
+import { toBoolean } from '../utils/util'
+import { applyFormula, type FormulaContext, type OrOperation } from './formula'
+
+export const applyOrFormula = (formula: OrOperation, ctx: FormulaContext) => {
+  for (let i = 0; i < (formula.arguments ?? []).length; i++) {
+    const arg = (formula.arguments ?? [])[i]
+    if (
+      toBoolean(applyFormula(arg?.formula, ctx, ['arguments', i, 'formula']))
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+export const applyEvaluateAllOrFormula = (
+  formula: OrOperation,
+  ctx: FormulaContext,
+) => {
+  let orResult = false
+  for (let i = 0; i < (formula.arguments ?? []).length; i++) {
+    const arg = (formula.arguments ?? [])[i]
+    const argResult = applyFormula(arg?.formula, ctx, [
+      'arguments',
+      i,
+      'formula',
+    ])
+    if (toBoolean(argResult)) {
+      orResult = true
+    }
+  }
+  return orResult
+}

package/src/formula/pathFormula.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'bun:test'
+import type { PathOperation } from './formula'
+import { applyPathFormula } from './pathFormula'
+
+describe('applyPathFormula', () => {
+  it('returns the value at the given path', () => {
+    const formula: PathOperation = { type: 'path', path: ['foo', 'bar'] }
+    const data: any = { foo: { bar: 42 } }
+    expect(applyPathFormula(formula, data)).toBe(42)
+  })
+
+  it('returns undefined if the path does not exist', () => {
+    const formula: PathOperation = { type: 'path', path: ['foo', 'baz'] }
+    const data: any = { foo: { bar: 42 } }
+    expect(applyPathFormula(formula, data)).toBeUndefined()
+  })
+
+  it('returns null if intermediate value is not an object', () => {
+    const formula: PathOperation = { type: 'path', path: ['foo', 'bar', 'baz'] }
+    const data: any = { foo: { bar: 42 } }
+    expect(applyPathFormula(formula, data)).toBeNull()
+  })
+
+  it('returns the root value if path is empty', () => {
+    const formula: PathOperation = { type: 'path', path: [] }
+    const data: any = { foo: 1 }
+    expect(applyPathFormula(formula, data)).toEqual(data)
+  })
+
+  it('works with numeric keys', () => {
+    const formula: PathOperation = { type: 'path', path: ['arr', 1] }
+    const data: any = { arr: [10, 20, 30] }
+    expect(applyPathFormula(formula, data)).toBe(20)
+  })
+})

package/src/formula/pathFormula.ts

@@ -0,0 +1,17 @@
+import type { FormulaContext, PathOperation } from './formula'
+
+export const applyPathFormula = (
+  formula: PathOperation,
+  data: FormulaContext['data'],
+) => {
+  let input: any = data
+  for (const key of formula.path) {
+    if (input && typeof input === 'object') {
+      input = input[key]
+    } else {
+      return null
+    }
+  }
+
+  return input
+}

package/src/formula/recordFormula.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test'
+import type { RecordOperation } from './formula'
+import { valueFormula } from './formulaUtils'
+import { applyRecordFormula } from './recordFormula'
+import {
+  createTestFormulaContext,
+  createTestFormulaContextForAllPaths,
+} from './testUtils.test'
+
+describe('applyRecordFormula', () => {
+  it('returns an object with evaluated entries', () => {
+    const formula: RecordOperation = {
+      type: 'record',
+      entries: [
+        { name: 'a', formula: valueFormula(1) },
+        { name: 'b', formula: valueFormula('hello') },
+        { name: 'c', formula: valueFormula(true) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyRecordFormula(formula, ctx)).toEqual({
+      a: 1,
+      b: 'hello',
+      c: true,
+    })
+  })
+
+  it('returns an empty object if entries is empty', () => {
+    const formula: RecordOperation = {
+      type: 'record',
+      entries: [],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyRecordFormula(formula, ctx)).toEqual({})
+  })
+
+  it('evaluates all formulas and reports results in "report" mode', () => {
+    const formula: RecordOperation = {
+      type: 'record',
+      entries: [
+        { name: 'x', formula: valueFormula('foo') },
+        { name: 'y', formula: valueFormula('bar') },
+      ],
+    }
+    const results: Record<string, any> = {}
+    const ctx = createTestFormulaContextForAllPaths(
+      {},
+      (path, result) => (results[path.join('/')] = result),
+    )
+    expect(applyRecordFormula(formula, ctx)).toEqual({ x: 'foo', y: 'bar' })
+    expect(results).toMatchObject({
+      'entries/0/formula': 'foo',
+      'entries/1/formula': 'bar',
+    })
+  })
+})

package/src/formula/recordFormula.ts

@@ -0,0 +1,17 @@
+import {
+  applyFormula,
+  type FormulaContext,
+  type RecordOperation,
+} from './formula'
+
+export const applyRecordFormula = (
+  formula: RecordOperation,
+  ctx: FormulaContext,
+) => {
+  return Object.fromEntries(
+    (formula.entries ?? []).map((entry, i) => [
+      entry.name,
+      applyFormula(entry.formula, ctx, ['entries', i, 'formula']),
+    ]),
+  )
+}