@nordcraft/core 1.0.95 → 1.0.96

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']),
+    ]),
+  )
+}

package/src/formula/switchFormula.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'bun:test'
+import { applyFormula, type SwitchOperation } from './formula'
+import { valueFormula } from './formulaUtils'
+import {
+  applyEvaluateAllSwitchFormula,
+  applySwitchFormula,
+} from './switchFormula'
+import {
+  createTestFormulaContext,
+  createTestFormulaContextForAllPaths,
+} from './testUtils.test'
+
+describe('applySwitchFormula', () => {
+  it('returns the first matching case value', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        { condition: valueFormula(false), formula: valueFormula('no') },
+        { condition: valueFormula(true), formula: valueFormula('yes') },
+        {
+          condition: valueFormula(true),
+          formula: valueFormula('should not match'),
+        },
+      ],
+      default: valueFormula('default'),
+    }
+    const ctx = createTestFormulaContext()
+    expect(applySwitchFormula(formula, ctx)).toBe('yes')
+  })
+
+  it('returns the default value if no case matches', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        { condition: valueFormula(false), formula: valueFormula('no') },
+        { condition: valueFormula(false), formula: valueFormula('nope') },
+      ],
+      default: valueFormula('default'),
+    }
+    const ctx = createTestFormulaContext()
+    expect(applySwitchFormula(formula, ctx)).toBe('default')
+  })
+
+  it('evaluates conditions using context data', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        {
+          condition: { type: 'path', path: ['foo'] },
+          formula: valueFormula('foo matched'),
+        },
+        { condition: valueFormula(true), formula: valueFormula('fallback') },
+      ],
+      default: valueFormula('default'),
+    }
+    const ctx = createTestFormulaContext({ foo: true })
+    expect(applySwitchFormula(formula, ctx)).toBe('foo matched')
+  })
+})
+
+describe('applyEvaluateAllSwitchFormula', () => {
+  it('returns the first matching case value, but evaluates all cases and default', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        { condition: valueFormula(false), formula: valueFormula('no') },
+        { condition: valueFormula(true), formula: valueFormula('yes') },
+        {
+          condition: valueFormula(true),
+          formula: valueFormula('should not match'),
+        },
+      ],
+      default: valueFormula('default'),
+    }
+    const results: Record<string, any> = {}
+    const ctx = createTestFormulaContextForAllPaths(
+      {},
+      (path, result) => (results[path.join('/')] = result),
+    )
+    // We use applyFormula directly since it will gather results in EVALUATE ALL PATHS mode
+    const result = applyFormula(formula, ctx, [])
+    expect(result).toBe('yes')
+    expect(results).toMatchObject({
+      'cases/0/condition': false,
+      'cases/0/formula': 'no',
+      'cases/1/condition': true,
+      'cases/1/formula': 'yes',
+      'cases/2/condition': true,
+      'cases/2/formula': 'should not match',
+      default: 'default',
+    })
+  })
+
+  it('returns the default value if no case matches', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        { condition: valueFormula(false), formula: valueFormula('no') },
+        { condition: valueFormula(false), formula: valueFormula('nope') },
+      ],
+      default: valueFormula('default'),
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyEvaluateAllSwitchFormula(formula, ctx)).toBe('default')
+  })
+
+  it('evaluates conditions using context data', () => {
+    const formula: SwitchOperation = {
+      type: 'switch',
+      cases: [
+        {
+          condition: { type: 'path', path: ['foo'] },
+          formula: valueFormula('foo matched'),
+        },
+        { condition: valueFormula(true), formula: valueFormula('fallback') },
+      ],
+      default: valueFormula('default'),
+    }
+    const ctx = createTestFormulaContext({ foo: true })
+    expect(applyEvaluateAllSwitchFormula(formula, ctx)).toBe('foo matched')
+  })
+})

package/src/formula/switchFormula.ts

@@ -0,0 +1,54 @@
+import { toBoolean } from '../utils/util'
+import {
+  applyFormula,
+  type FormulaContext,
+  type SwitchOperation,
+} from './formula'
+
+export const applySwitchFormula = (
+  formula: SwitchOperation,
+  ctx: FormulaContext,
+) => {
+  // Evaluates cases until one matches
+  for (let i = 0; i < (formula.cases ?? []).length; i++) {
+    const switchCase = (formula.cases ?? [])[i]
+    if (
+      toBoolean(
+        applyFormula(switchCase?.condition, ctx, ['cases', i, 'condition']),
+      )
+    ) {
+      return applyFormula(switchCase?.formula, ctx, ['cases', i, 'formula'])
+    }
+  }
+  return applyFormula(formula.default, ctx, ['default'])
+}
+
+export const applyEvaluateAllSwitchFormula = (
+  formula: SwitchOperation,
+  ctx: FormulaContext,
+) => {
+  // Evaluate all cases and the default, but only returns the first matching case or the default
+  let switchResult: { match: true; value: any } | null = null
+  for (let i = 0; i < (formula.cases ?? []).length; i++) {
+    const switchCase = (formula.cases ?? [])[i]
+    const conditionValue = applyFormula(switchCase?.condition, ctx, [
+      'cases',
+      i,
+      'condition',
+    ])
+    const formulaValue = applyFormula(switchCase?.formula, ctx, [
+      'cases',
+      i,
+      'formula',
+    ])
+    if (toBoolean(conditionValue) && switchResult === null) {
+      switchResult = { match: true, value: formulaValue }
+    }
+  }
+  const defaultValue = applyFormula(formula.default, ctx, ['default'])
+  if (switchResult !== null) {
+    return switchResult.value
+  } else {
+    return defaultValue
+  }
+}