@nordcraft/core 1.0.94 → 1.0.96

package/src/formula/applyFormula.test.ts

@@ -0,0 +1,151 @@
+import { describe, expect, it } from 'bun:test'
+import type { ComponentFormula } from '../component/component.types'
+import { applyApplyFormula } from './applyFormula'
+import {
+  applyFormula,
+  type ApplyOperation,
+  type FormulaContext,
+} from './formula'
+import { valueFormula } from './formulaUtils'
+import { createTestFormulaContext } from './testUtils.test'
+
+describe('applyApplyFormula', () => {
+  it('applies a simple value formula from the component', () => {
+    const componentFormula: ComponentFormula = {
+      name: 'isSimple',
+      formula: valueFormula(true),
+    }
+    const formula: ApplyOperation = {
+      type: 'apply',
+      name: 'isSimple',
+      arguments: [],
+    }
+    const ctx: FormulaContext = {
+      ...createTestFormulaContext(),
+      component: {
+        formulas: { isSimple: componentFormula },
+        name: 'TestComponent',
+        attributes: {},
+        variables: {},
+        apis: {},
+        nodes: {},
+      },
+    }
+    // The result should be the result of the inner formula (here, just the value of b)
+    expect(applyFormula(formula, ctx, [])).toEqual(true)
+  })
+  it('applies a formula from the component with arguments', () => {
+    const componentFormula: ComponentFormula = {
+      name: 'sum',
+      formula: {
+        type: 'function',
+        name: '@toddle/sum',
+        arguments: [
+          {
+            name: 'Array',
+            formula: {
+              type: 'array',
+              arguments: [
+                {
+                  formula: { type: 'path', path: ['Args', 'a'] },
+                },
+                {
+                  formula: { type: 'path', path: ['Args', 'b'] },
+                },
+              ],
+            },
+            type: { type: 'Array' },
+          },
+        ],
+      },
+      arguments: [
+        { name: 'a', testValue: 2 },
+        { name: 'b', testValue: 3 },
+      ],
+    }
+    const formula: ApplyOperation = {
+      type: 'apply',
+      name: 'sum',
+      arguments: [
+        { name: 'a', formula: valueFormula(2) },
+        { name: 'b', formula: valueFormula(3) },
+      ],
+    }
+    const ctx: FormulaContext = {
+      ...createTestFormulaContext(),
+      component: {
+        formulas: { sum: componentFormula },
+        name: 'TestComponent',
+        attributes: {},
+        variables: {},
+        apis: {},
+        nodes: {},
+      },
+    }
+    // The result should be the result of the inner formula (here, just the value of b)
+    expect(applyFormula(formula, ctx, [])).toEqual(5)
+  })
+
+  it('returns null if the formula does not exist in the component', () => {
+    const formula: ApplyOperation = {
+      type: 'apply',
+      name: 'missing',
+      arguments: [],
+    }
+    const ctx: FormulaContext = {
+      ...createTestFormulaContext(),
+      component: { formulas: {} } as any,
+      env: { logErrors: true } as any,
+    }
+    expect(applyApplyFormula(formula, ctx)).toBeNull()
+  })
+
+  it('returns cached result if available', () => {
+    const componentFormula = {
+      name: 'cached',
+      formula: valueFormula('cached-result'),
+    }
+    const formula: ApplyOperation = {
+      type: 'apply',
+      name: 'cached',
+      arguments: [],
+    }
+    const cache = new Map()
+    cache.set({}, { hit: true, data: 'from-cache' })
+    const ctx: FormulaContext = {
+      ...createTestFormulaContext(),
+      component: {
+        formulas: { cached: componentFormula },
+      } as any,
+      formulaCache: {
+        cached: {
+          get: () => ({ hit: true, data: 'from-cache' }),
+          set: () => {},
+        },
+      },
+    }
+    expect(applyApplyFormula(formula, ctx)).toBe('from-cache')
+  })
+
+  it('can use built in formulas', () => {
+    const formula = {
+      type: 'function',
+      name: '@toddle/string',
+      arguments: [
+        {
+          name: 'Input',
+          formula: { type: 'value', value: 'test' },
+          type: { type: 'Any' },
+        },
+      ],
+      display_name: 'String',
+    }
+    const ctx: FormulaContext = {
+      ...createTestFormulaContext(),
+      component: {
+        formulas: {},
+      } as any,
+    }
+    expect(applyFormula(formula as any, ctx)).toBe('test')
+  })
+})

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 {
@@ -39,13 +51,13 @@ export interface FunctionOperation extends BaseOperation {
   name: string
   display_name?: Nullable<string>
   package?: Nullable<string>
-  arguments: FunctionArgument[]
+  arguments?: Nullable<FunctionArgument[]>
   variableArguments?: Nullable<boolean>
 }
 
 export interface RecordOperation extends BaseOperation {
   type: 'record'
-  entries: FunctionArgument[]
+  entries?: Nullable<FunctionArgument[]>
 }
 
 export interface ObjectOperation extends BaseOperation {
@@ -55,23 +67,23 @@ export interface ObjectOperation extends BaseOperation {
 
 export interface ArrayOperation extends BaseOperation {
   type: 'array'
-  arguments: Array<{ formula: Formula }>
+  arguments?: Nullable<Array<{ formula: Formula }>>
 }
 
 export interface OrOperation extends BaseOperation {
   type: 'or'
-  arguments: Array<{ formula: Formula }>
+  arguments?: Nullable<Array<{ formula: Formula }>>
 }
 
 export interface AndOperation extends BaseOperation {
   type: 'and'
-  arguments: Array<{ formula: Formula }>
+  arguments?: Nullable<Array<{ formula: Formula }>>
 }
 
 export interface ApplyOperation extends BaseOperation {
   type: 'apply'
   name: string
-  arguments: FunctionArgument[]
+  arguments?: Nullable<FunctionArgument[]>
 }
 
 export interface ValueOperation extends BaseOperation {
@@ -79,14 +91,22 @@ 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'
-  cases: Array<{
-    condition: Formula
-    formula: Formula
-  }>
+  cases?: Nullable<
+    Array<{
+      condition: Formula
+      formula: Formula
+    }>
+  >
   default: Formula
 }
 
@@ -102,7 +122,7 @@ export type Formula =
   | ValueOperation
   | ApplyOperation
 
-export type FormulaContext = {
+export interface FormulaContext {
   component: Component | undefined
   formulaCache?: Nullable<
     Record<
@@ -121,6 +141,8 @@ export type FormulaContext = {
     getCustomFormula: CustomFormulaHandler
     errors: Error[]
   }
+  jsonPath?: Array<string | number> | undefined
+  reportFormulaEvaluation?: FormulaEvaluationReporter | undefined
   env: ToddleEnv | undefined
 }
 
@@ -183,220 +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)
@@ -406,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