@nordcraft/core 1.0.94 → 1.0.96

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
+  }
+}

package/src/formula/testUtils.test.ts

@@ -0,0 +1,68 @@
+import type { FormulaContext } from './formula'
+import type { FormulaEvaluationReporter } from './formulaTypes'
+
+// Register all core formulas globally for tests
+if (!(globalThis as any).__CORE_FORMULAS__) {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const libFormulas = require('../../../lib/dist/formulas')
+  ;(globalThis as any).__CORE_FORMULAS__ = Object.fromEntries(
+    Object.entries(libFormulas).map(([name, module]) => [
+      '@toddle/' + name,
+      ((module as any).default ?? module) as any,
+    ]),
+  )
+}
+
+// Helper to create a minimal context
+export const createTestFormulaContext = (data: any = {}): FormulaContext => {
+  const coreFormulas = (globalThis as any).__CORE_FORMULAS__ as
+    | Record<string, any>
+    | undefined
+  return {
+    component: undefined,
+    formulaCache: {},
+    data,
+    root: {} as Document,
+    package: undefined,
+    toddle: {
+      getFormula: (name: string) => coreFormulas?.[name],
+      getCustomFormula: () => undefined,
+      errors: [],
+    },
+    env: {
+      logErrors: true,
+      runtime: 'page',
+      branchName: 'main',
+      isServer: false,
+      request: undefined,
+    },
+    reportFormulaEvaluation: undefined,
+    jsonPath: [],
+  }
+}
+
+// Helper to create a minimal context when evaluating all paths
+export const createTestFormulaContextForAllPaths = (
+  data: any = {},
+  formulaEvaluationReporter: FormulaEvaluationReporter,
+): FormulaContext => ({
+  component: undefined,
+  formulaCache: {},
+  data,
+  root: undefined,
+  package: undefined,
+  toddle: {
+    getFormula: (name: string) => coreFormulas[name],
+    getCustomFormula: () => undefined,
+    errors: [],
+  },
+  env: {
+    logErrors: true,
+    runtime: 'page',
+    branchName: 'main',
+    isServer: false,
+    request: undefined,
+  },
+  jsonPath: [],
+  reportFormulaEvaluation: formulaEvaluationReporter,
+})

package/src/types.ts

@@ -85,7 +85,7 @@ export type ArgumentInputDataFunction = (
 
 export type CustomFormulaHandler = (
   name: string,
-  packageName: string | undefined,
+  packageName: string | null | undefined,
 ) => PluginFormula<FormulaHandlerV2> | undefined
 
 export type FormulaLookup = (name: string) => FormulaHandler | undefined

package/src/utils/measure.ts

@@ -31,7 +31,13 @@ export const measure = (key: string, details: Record<string, unknown>) => {
   const start = performance.now()
   STACK.push(key)
 
+  let _stopped = false
   return (extraDetails?: Record<string, unknown>) => {
+    if (_stopped) {
+      return
+    }
+
+    _stopped = true
     const end = performance.now()
     const mergedDetails = extraDetails
       ? { ...details, ...extraDetails }