@nordcraft/core 1.0.95 → 1.0.96

package/src/formula/applyFormula.ts

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+import { measure } from '../utils/measure'
+import {
+  applyFormula,
+  type ApplyOperation,
+  type FormulaContext,
+} from './formula'
+
+export const applyApplyFormula = (
+  formula: ApplyOperation,
+  ctx: FormulaContext,
+) => {
+  const componentFormula = ctx.component?.formulas?.[formula.name]
+  if (!componentFormula) {
+    if (ctx.env?.logErrors) {
+      console.log(
+        'Component does not have a formula with the name ',
+        formula.name,
+      )
+    }
+    return null
+  }
+  const stopMeasure = measure(`Formula: ${componentFormula.name}`, {
+    formula,
+    component: ctx.component?.name,
+  })
+  const Input = Object.fromEntries(
+    (formula.arguments ?? []).map((arg, i) =>
+      arg.isFunction
+        ? [
+            arg.name,
+            (Args: any) =>
+              applyFormula(
+                arg.formula,
+                {
+                  ...ctx,
+                  data: {
+                    ...ctx.data,
+                    Args: ctx.data.Args
+                      ? { ...Args, '@toddle.parent': ctx.data.Args }
+                      : Args,
+                  },
+                },
+                ['arguments', i],
+              ),
+          ]
+        : [arg.name, applyFormula(arg.formula, ctx, ['arguments', i])],
+    ),
+  )
+  const data = {
+    ...ctx.data,
+    Args: ctx.data.Args ? { ...Input, '@toddle.parent': ctx.data.Args } : Input,
+  }
+  const cache = ctx.formulaCache?.[formula.name]?.get(data)
+
+  if (cache?.hit) {
+    stopMeasure({ cache: 'hit' })
+    return cache.data
+  } else {
+    const result = applyFormula(
+      componentFormula.formula,
+      {
+        ...ctx,
+        data,
+      },
+      ['formula'],
+    )
+    ctx.formulaCache?.[formula.name]?.set(data, result)
+    stopMeasure({ cache: 'miss' })
+    return result
+  }
+}

package/src/formula/arrayFormula.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'bun:test'
+import { applyArrayFormula } from './arrayFormula'
+import type { ArrayOperation } from './formula'
+import { valueFormula } from './formulaUtils'
+import {
+  createTestFormulaContext,
+  createTestFormulaContextForAllPaths,
+} from './testUtils.test'
+
+describe('applyArrayFormula', () => {
+  it('returns an array with evaluated values', () => {
+    const formula: ArrayOperation = {
+      type: 'array',
+      arguments: [
+        { formula: valueFormula(1) },
+        { formula: valueFormula('hello') },
+        { formula: valueFormula(true) },
+      ],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyArrayFormula(formula, ctx)).toEqual([1, 'hello', true])
+  })
+
+  it('returns an empty array if arguments is empty', () => {
+    const formula: ArrayOperation = {
+      type: 'array',
+      arguments: [],
+    }
+    const ctx = createTestFormulaContext()
+    expect(applyArrayFormula(formula, ctx)).toEqual([])
+  })
+
+  it('evaluates all formulas and reports results in "report" mode', () => {
+    const formula: ArrayOperation = {
+      type: 'array',
+      arguments: [
+        { formula: valueFormula('foo') },
+        { formula: valueFormula('bar') },
+      ],
+    }
+    const results: Record<string, any> = {}
+    const ctx = createTestFormulaContextForAllPaths(
+      {},
+      (path, result) => (results[path.join('/')] = result),
+    )
+    expect(applyArrayFormula(formula, ctx)).toEqual(['foo', 'bar'])
+    expect(results).toMatchObject({
+      'arguments/0/formula': 'foo',
+      'arguments/1/formula': 'bar',
+    })
+  })
+})

package/src/formula/arrayFormula.ts

@@ -0,0 +1,14 @@
+import {
+  applyFormula,
+  type ArrayOperation,
+  type FormulaContext,
+} from './formula'
+
+export const applyArrayFormula = (
+  formula: ArrayOperation,
+  ctx: FormulaContext,
+) => {
+  return (formula.arguments ?? []).map((entry, i) =>
+    applyFormula(entry.formula, ctx, ['arguments', i, 'formula']),
+  )
+}

package/src/formula/formula.ts

@@ -2,19 +2,31 @@
 import type { Component, ComponentData } from '../component/component.types'
 import type {
   CustomFormulaHandler,
-  FormulaHandler,
   FormulaLookup,
   NordcraftMetadata,
   Nullable,
   Runtime,
-  Toddle,
 } from '../types'
-import { measure } from '../utils/measure'
-import { isDefined, toBoolean } from '../utils/util'
-import { type PluginFormula, type ToddleFormula } from './formulaTypes'
+import { isDefined } from '../utils/util'
+import { applyAndFormula, applyEvaluateAllAndFormula } from './andFormula'
+import { applyApplyFormula } from './applyFormula'
+import { applyArrayFormula } from './arrayFormula'
+import {
+  type FormulaEvaluationReporter,
+  type PluginFormula,
+  type ToddleFormula,
+} from './formulaTypes'
+import { applyFunctionFormula } from './functionFormula'
+import { applyObjectFormula } from './objectFormula'
+import { applyEvaluateAllOrFormula, applyOrFormula } from './orFormula'
+import { applyPathFormula } from './pathFormula'
+import { applyRecordFormula } from './recordFormula'
+import {
+  applyEvaluateAllSwitchFormula,
+  applySwitchFormula,
+} from './switchFormula'
 
 // Define the some objects types as union of ServerSide and ClientSide runtime types as applyFormula is used in both
-declare const document: Document | undefined
 type ShadowRoot = DocumentFragment
 
 interface BaseOperation extends NordcraftMetadata {
@@ -23,7 +35,7 @@ interface BaseOperation extends NordcraftMetadata {
 
 export interface PathOperation extends BaseOperation {
   type: 'path'
-  path: string[]
+  path: Array<string | number>
 }
 
 export interface FunctionArgument {
@@ -79,7 +91,13 @@ export interface ValueOperation extends BaseOperation {
   value: ValueOperationValue
 }
 
-export type ValueOperationValue = string | number | boolean | null | object
+export type ValueOperationValue =
+  | string
+  | number
+  | boolean
+  | null
+  | object
+  | undefined
 
 export interface SwitchOperation extends BaseOperation {
   type: 'switch'
@@ -104,7 +122,7 @@ export type Formula =
   | ValueOperation
   | ApplyOperation
 
-export type FormulaContext = {
+export interface FormulaContext {
   component: Component | undefined
   formulaCache?: Nullable<
     Record<
@@ -123,6 +141,8 @@ export type FormulaContext = {
     getCustomFormula: CustomFormulaHandler
     errors: Error[]
   }
+  jsonPath?: Array<string | number> | undefined
+  reportFormulaEvaluation?: FormulaEvaluationReporter | undefined
   env: ToddleEnv | undefined
 }
 
@@ -185,222 +205,61 @@ export const isToddleFormula = <Handler>(
 
 export function applyFormula(
   formula: Formula | string | number | undefined | null | boolean,
-  ctx: FormulaContext,
+  _ctx: FormulaContext,
+  extendedPath?: Array<string | number> | undefined,
 ): any {
+  const path = [...(_ctx?.jsonPath ?? []), ...(extendedPath ?? [])]
+  const ctx = { ..._ctx, jsonPath: path }
+  const report = (value: any, p: Array<string | number> = path) => {
+    ctx?.reportFormulaEvaluation?.(p, value)
+    return value
+  }
+
   if (!isFormula(formula)) {
-    return formula
+    return report(formula)
   }
   try {
     switch (formula.type) {
-      case 'value':
-        return formula.value
+      case 'value': {
+        return report(formula.value)
+      }
       case 'path': {
-        let input: any = ctx.data
-        for (const key of formula.path) {
-          if (input && typeof input === 'object') {
-            input = input[key]
-          } else {
-            return null
-          }
-        }
-
-        return input
+        return report(applyPathFormula(formula, ctx.data))
       }
       case 'switch': {
-        for (const branch of formula.cases ?? []) {
-          if (toBoolean(applyFormula(branch.condition, ctx))) {
-            return applyFormula(branch.formula, ctx)
-          }
+        if (ctx.reportFormulaEvaluation) {
+          return report(applyEvaluateAllSwitchFormula(formula, ctx))
         }
-        return applyFormula(formula.default, ctx)
+        return applySwitchFormula(formula, ctx)
       }
       case 'or': {
-        for (const entry of formula.arguments ?? []) {
-          if (toBoolean(applyFormula(entry.formula, ctx))) {
-            return true
-          }
+        if (ctx.reportFormulaEvaluation) {
+          return report(applyEvaluateAllOrFormula(formula, ctx))
         }
-        return false
+        return applyOrFormula(formula, ctx)
       }
       case 'and': {
-        for (const entry of formula.arguments ?? []) {
-          if (!toBoolean(applyFormula(entry.formula, ctx))) {
-            return false
-          }
+        if (ctx.reportFormulaEvaluation) {
+          return report(applyEvaluateAllAndFormula(formula, ctx))
         }
-        return true
+        return applyAndFormula(formula, ctx)
+      }
+      case 'object': {
+        return report(applyObjectFormula(formula, ctx))
+      }
+      case 'record': {
+        // object used to be called record, there are still examples in the wild.
+        return report(applyRecordFormula(formula, ctx))
+      }
+      case 'array': {
+        return report(applyArrayFormula(formula, ctx))
       }
       case 'function': {
-        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,
-                      },
-                    })
-                : applyFormula(arg.formula, ctx),
-            }),
-            {},
-          )
-          try {
-            if (isToddleFormula(newFunc)) {
-              return applyFormula(newFunc.formula, {
-                ...ctx,
-                data: { ...ctx.data, Args: args },
-              })
-            } 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) =>
-              arg.isFunction
-                ? (Args: any) =>
-                    applyFormula(arg.formula, {
-                      ...ctx,
-                      data: {
-                        ...ctx.data,
-                        Args: ctx.data.Args
-                          ? { ...Args, '@toddle.parent': ctx.data.Args }
-                          : Args,
-                      },
-                    })
-                : applyFormula(arg.formula, ctx),
-            )
-            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
+        return report(applyFunctionFormula(formula, ctx))
       }
-      case 'object':
-        return Object.fromEntries(
-          formula.arguments?.map((entry) => [
-            entry.name,
-            applyFormula(entry.formula, ctx),
-          ]) ?? [],
-        )
-      case 'record': // object used to be called record, there are still examples in the wild.
-        return Object.fromEntries(
-          (formula.entries ?? []).map((entry) => [
-            entry.name,
-            applyFormula(entry.formula, ctx),
-          ]),
-        )
-      case 'array':
-        return (formula.arguments ?? []).map((entry) =>
-          applyFormula(entry.formula, ctx),
-        )
       case 'apply': {
-        const componentFormula = ctx.component?.formulas?.[formula.name]
-        if (!componentFormula) {
-          if (ctx.env?.logErrors) {
-            console.log(
-              'Component does not have a formula with the name ',
-              formula.name,
-            )
-          }
-          return null
-        }
-        const stopMeasure = measure(`Formula: ${componentFormula.name}`, {
-          formula,
-          component: ctx.component?.name,
-        })
-        const Input = Object.fromEntries(
-          (formula.arguments ?? []).map((arg) =>
-            arg.isFunction
-              ? [
-                  arg.name,
-                  (Args: any) =>
-                    applyFormula(arg.formula, {
-                      ...ctx,
-                      data: {
-                        ...ctx.data,
-                        Args: ctx.data.Args
-                          ? { ...Args, '@toddle.parent': ctx.data.Args }
-                          : Args,
-                      },
-                    }),
-                ]
-              : [arg.name, applyFormula(arg.formula, ctx)],
-          ),
-        )
-        const data = {
-          ...ctx.data,
-          Args: ctx.data.Args
-            ? { ...Input, '@toddle.parent': ctx.data.Args }
-            : Input,
-        }
-        const cache = ctx.formulaCache?.[formula.name]?.get(data)
-
-        if (cache?.hit) {
-          stopMeasure({ cache: 'hit' })
-          return cache.data
-        } else {
-          const result = applyFormula(componentFormula.formula, {
-            ...ctx,
-            data,
-          })
-          ctx.formulaCache?.[formula.name]?.set(data, result)
-          stopMeasure({ cache: 'miss' })
-          return result
-        }
+        return report(applyApplyFormula(formula, ctx))
       }
-
       default:
         if (ctx.env?.logErrors) {
           console.error('Could not recognize formula', formula)
@@ -410,6 +269,8 @@ export function applyFormula(
     if (ctx.env?.logErrors) {
       console.error(e)
     }
-    return null
+    return report(null)
   }
+
+  return report(undefined)
 }

package/src/formula/formulaTypes.ts

@@ -38,3 +38,8 @@ export interface GlobalFormulas<Handler = string | Function> {
     >
   >
 }
+
+export type FormulaEvaluationReporter = (
+  path: Array<string | number>,
+  result: any,
+) => void

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,

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