@nordcraft/search 1.0.39 → 1.0.40

package/src/rules/actions/legacyActionRule.ts

@@ -1,5 +1,10 @@
+import type {
+  ActionModel,
+  CustomActionArgument,
+} from '@nordcraft/core/dist/component/component.types'
+import { set } from '@nordcraft/core/dist/utils/collections'
 import type { Rule } from '../../types'
-import { isLegacyAction } from '../../util/helpers'
+import { isLegacyAction, renameArguments } from '../../util/helpers'
 
 export const legacyActionRule: Rule<{
   name: string
@@ -11,7 +16,6 @@ export const legacyActionRule: Rule<{
     if (nodeType !== 'action-model') {
       return
     }
-
     if (isLegacyAction(value)) {
       let details: { name: string } | undefined
       if ('name' in value) {
@@ -19,8 +23,166 @@ export const legacyActionRule: Rule<{
           name: value.name,
         }
       }
-
-      report(path, details)
+      report(
+        path,
+        details,
+        unfixableLegacyActions.has(value.name)
+          ? undefined
+          : !formulaNamedActions.includes(value.name) ||
+              // Check if the first argument is a value formula with a string value
+              (value.arguments?.[0].formula.type === 'value' &&
+                typeof value.arguments[0].formula.value === 'string')
+            ? ['replace-legacy-action']
+            : undefined,
+      )
     }
   },
+  fixes: {
+    'replace-legacy-action': ({ path, value, nodeType, files }) => {
+      if (nodeType !== 'action-model') {
+        return
+      }
+      if (!isLegacyAction(value)) {
+        return
+      }
+
+      let newAction: ActionModel | undefined
+      switch (value.name) {
+        case 'If': {
+          const trueActions = value.events?.['true']?.actions ?? []
+          const falseActions = value.events?.['false']?.actions ?? []
+          const trueCondition: CustomActionArgument | undefined =
+            (value.arguments ?? [])[0]
+          newAction = {
+            type: 'Switch',
+            cases: [
+              {
+                condition: trueCondition?.formula ?? null,
+                actions: trueActions,
+              },
+            ],
+            default: { actions: falseActions },
+          }
+          break
+        }
+        case 'PreventDefault': {
+          newAction = {
+            name: '@toddle/preventDefault',
+            arguments: [],
+            label: 'Prevent default',
+          }
+          break
+        }
+        case 'StopPropagation': {
+          newAction = {
+            name: '@toddle/stopPropagation',
+            arguments: [],
+            label: 'Stop propagation',
+          }
+          break
+        }
+        case 'UpdateVariable': {
+          const variableName =
+            value.arguments?.[0]?.formula.type === 'value'
+              ? value.arguments[0].formula.value
+              : undefined
+          if (typeof variableName !== 'string') {
+            break
+          }
+          const variableValue = value.arguments?.[1]?.formula
+          if (!variableValue) {
+            break
+          }
+          newAction = {
+            type: 'SetVariable',
+            variable: variableName,
+            data: variableValue,
+          }
+          break
+        }
+        case 'SetTimeout': {
+          newAction = {
+            ...value,
+            name: '@toddle/sleep',
+            arguments: renameArguments(
+              { 'Delay in ms': 'Delay in milliseconds' },
+              value.arguments,
+            ),
+            events: value.events?.['timeout']
+              ? { tick: value.events.timeout }
+              : undefined,
+            label: 'Sleep',
+          }
+          break
+        }
+        case 'SetInterval': {
+          newAction = {
+            ...value,
+            name: '@toddle/interval',
+            arguments: renameArguments(
+              { 'Interval in ms': 'Interval in milliseconds' },
+              value.arguments,
+            ),
+            label: 'Interval',
+          }
+          break
+        }
+        case 'Debug': {
+          newAction = {
+            ...value,
+            name: '@toddle/logToConsole',
+            label: 'Log to console',
+          }
+          break
+        }
+        case 'GoToURL': {
+          newAction = {
+            name: '@toddle/gotToURL', // Yes, the typo is in the action name
+            arguments: renameArguments({ url: 'URL' }, value.arguments),
+            label: 'Go to URL',
+          }
+          break
+        }
+        case 'TriggerEvent': {
+          const eventName =
+            value.arguments?.[0]?.formula.type === 'value'
+              ? value.arguments[0].formula.value
+              : undefined
+          if (typeof eventName !== 'string') {
+            break
+          }
+          const eventData = value.arguments?.[1]?.formula
+          if (!eventData) {
+            break
+          }
+          newAction = {
+            type: 'TriggerEvent',
+            event: eventName,
+            data: eventData,
+          }
+          break
+        }
+      }
+      if (newAction) {
+        return set(files, path, newAction)
+      }
+    },
+  },
 }
+
+// These actions take a first argument which is a formula as the name
+// of the thing to update/trigger. We can only safely autofix these if
+// the argument is a value operation and a string
+const formulaNamedActions = ['UpdateVariable', 'TriggerEvent']
+
+const unfixableLegacyActions = new Set([
+  'CopyToClipboard', // Previously, this action would JSON stringify non-string inputs
+  'Update URL parameter', // The user will need to pick a history mode (push/replace)
+  'Fetch', // This was mainly used for APIs v1
+  'FocusElement', // The new 'Focus' action takes an element as input - not a selector
+  'UpdateVariable', // The variable name could be a formula in the legacy version
+  'TriggerEvent', // The name of the event could be a formula in the legacy version
+  '@toddle/setSessionCookies', // The new 'Set cookie' action takes more arguments
+])
+
+export type LegacyActionRuleFix = 'replace-legacy-action'

package/src/rules/formulas/legacyFormulaRule.ts

@@ -1,7 +1,6 @@
 import type {
   AndOperation,
   ArrayOperation,
-  FunctionArgument,
   FunctionOperation,
   OrOperation,
   SwitchOperation,
@@ -11,6 +10,11 @@ import { omitKeys, set } from '@nordcraft/core/dist/utils/collections'
 import { isDefined } from '@nordcraft/core/dist/utils/util'
 import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
 import type { FormulaNode, NodeType, Rule } from '../../types'
+import {
+  ARRAY_ARGUMENT_MAPPINGS,
+  PREDICATE_ARGUMENT_MAPPINGS,
+  renameArguments,
+} from '../../util/helpers'
 
 export const legacyFormulaRule: Rule<{
   name: string
@@ -25,8 +29,10 @@ export const legacyFormulaRule: Rule<{
     report(
       data.path,
       { name: data.value.name },
-      // The TYPE formula cannot be autofixed since the types have changed between the 2 implementations
-      data.value.name !== 'TYPE' ? ['replace-legacy-formula'] : undefined,
+      // The TYPE and BOOLEAN formulas cannot be autofixed since the logic has changed between the 2 implementations
+      data.value.name !== 'TYPE' && data.value.name !== 'BOOLEAN'
+        ? ['replace-legacy-formula']
+        : undefined,
     )
   },
   fixes: {
@@ -372,14 +378,6 @@ export const legacyFormulaRule: Rule<{
           }
           return set(data.files, data.path, newAppendFormula)
         }
-        case 'BOOLEAN': {
-          const newBooleanFormula: FunctionOperation = {
-            ...data.value,
-            name: '@toddle/boolean',
-            display_name: 'Boolean',
-          }
-          return set(data.files, data.path, newBooleanFormula)
-        }
         case 'CLAMP': {
           const newClampFormula: FunctionOperation = {
             ...data.value,
@@ -845,23 +843,3 @@ const builtInFormulas = new Set([
   'uppercase',
 ])
 // cSpell: enable
-
-const ARRAY_ARGUMENT_MAPPINGS = { List: 'Array' }
-const PREDICATE_ARGUMENT_MAPPINGS = {
-  ...ARRAY_ARGUMENT_MAPPINGS,
-  'Predicate fx': 'Formula',
-}
-
-const renameArguments = (
-  mappings: Record<string, string>,
-  args: FunctionArgument[] | undefined,
-): FunctionArgument[] =>
-  args?.map((arg) => ({
-    ...arg,
-    // Let's adjust the names
-    name:
-      typeof arg.name === 'string'
-        ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-          (mappings[arg.name] ?? arg.name)
-        : arg.name,
-  })) ?? []

package/src/rules/formulas/noReferenceProjectFormulaRule.test.ts

@@ -1,8 +1,10 @@
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
 import { describe, expect, test } from 'bun:test'
+import { fixProject } from '../../fixProject'
 import { searchProject } from '../../searchProject'
 import { noReferenceProjectFormulaRule } from './noReferenceProjectFormulaRule'
 
-describe('noReferenceFormulaRule', () => {
+describe('find noReferenceFormulaRule', () => {
   test('should detect unused global formulas', () => {
     const problems = Array.from(
       searchProject({
@@ -289,3 +291,36 @@ describe('noReferenceFormulaRule', () => {
     expect(problems).toHaveLength(0)
   })
 })
+
+describe('fix noReferenceFormulaRule', () => {
+  test('should remove unused global formulas', () => {
+    const projectFiles: ProjectFiles = {
+      formulas: {
+        'my-formula': {
+          name: 'my-formula',
+          arguments: [],
+          formula: {
+            type: 'value',
+            value: 'value',
+          },
+        },
+      },
+      components: {
+        test: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: projectFiles,
+      rule: noReferenceProjectFormulaRule,
+      fixType: 'delete-project-formula',
+    })
+    expect(fixedProject.formulas).toEqual({})
+  })
+})

package/src/rules/formulas/noReferenceProjectFormulaRule.ts

@@ -1,92 +1,106 @@
 import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
 import type { Formula } from '@nordcraft/core/dist/formula/formula'
 import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
+import { omit } from '@nordcraft/core/dist/utils/collections'
 import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
 import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
-import type { Rule } from '../../types'
+import type { NodeType, Rule } from '../../types'
 
 export const noReferenceProjectFormulaRule: Rule<void> = {
   code: 'no-reference project formula',
   level: 'warning',
   category: 'No References',
-  visit: (report, { path, files, value, nodeType, memo }) => {
-    if (nodeType !== 'project-formula' || value.exported === true) {
+  visit: (report, details) => {
+    if (hasReferences(details)) {
       return
     }
+    report(details.path, undefined, ['delete-project-formula'])
+  },
+  fixes: {
+    'delete-project-formula': (data) => {
+      if (hasReferences(data)) {
+        return
+      }
+      return omit(data.files, data.path)
+    },
+  },
+}
 
-    // Check in all API services first, since that should be quick
-    for (const apiService of Object.values(files.services ?? {})) {
-      const service = new ToddleApiService({
-        service: apiService,
-        globalFormulas: { formulas: files.formulas, packages: files.packages },
-      })
-      const formulas = service.formulasInService()
-      for (const { path: _formulaPath, formula } of formulas) {
-        // Check if the formula is used in the formula
-        if (checkFormula(formula, value.name)) {
-          return
-        }
+export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
+
+const hasReferences = ({ value, files, nodeType, memo }: NodeType) => {
+  if (nodeType !== 'project-formula' || value.exported === true) {
+    return true
+  }
+
+  // Check in all API services first, since that should be quick
+  for (const apiService of Object.values(files.services ?? {})) {
+    const service = new ToddleApiService({
+      service: apiService,
+      globalFormulas: { formulas: files.formulas, packages: files.packages },
+    })
+    const formulas = service.formulasInService()
+    for (const { path: _formulaPath, formula } of formulas) {
+      // Check if the formula is used in the formula
+      if (checkFormula(formula, value.name)) {
+        return true
       }
     }
+  }
 
-    // Check routes before components, since they should be quicker
-    for (const projectRoute of Object.values(files.routes ?? {})) {
-      const route = new ToddleRoute({
-        route: projectRoute,
-        globalFormulas: { formulas: files.formulas, packages: files.packages },
-      })
-      const formulas = route.formulasInRoute()
-      for (const { path: _formulaPath, formula } of formulas) {
-        // Check if the formula is used in the formula
-        if (checkFormula(formula, value.name)) {
-          return
-        }
+  // Check routes before components, since they should be quicker
+  for (const projectRoute of Object.values(files.routes ?? {})) {
+    const route = new ToddleRoute({
+      route: projectRoute,
+      globalFormulas: { formulas: files.formulas, packages: files.packages },
+    })
+    const formulas = route.formulasInRoute()
+    for (const { path: _formulaPath, formula } of formulas) {
+      // Check if the formula is used in the formula
+      if (checkFormula(formula, value.name)) {
+        return true
       }
     }
+  }
 
-    const componentFormulaReferences = memo(
-      'componentFormulaReferences',
-      () => {
-        const usedFormulas = new Set<string>()
-        for (const component of Object.values(files.components)) {
-          const c = new ToddleComponent({
-            // Enforce that the component is not undefined since we're iterating
-            component: component!,
-            getComponent: (name) => files.components[name],
-            packageName: undefined,
-            globalFormulas: {
-              formulas: files.formulas,
-              packages: files.packages,
-            },
-          })
-          for (const { formula } of c.formulasInComponent()) {
-            if (formula.type === 'function') {
-              usedFormulas.add(formula.name)
-            }
-          }
+  const componentFormulaReferences = memo('componentFormulaReferences', () => {
+    const usedFormulas = new Set<string>()
+    for (const component of Object.values(files.components)) {
+      const c = new ToddleComponent({
+        // Enforce that the component is not undefined since we're iterating
+        component: component!,
+        getComponent: (name) => files.components[name],
+        packageName: undefined,
+        globalFormulas: {
+          formulas: files.formulas,
+          packages: files.packages,
+        },
+      })
+      for (const { formula } of c.formulasInComponent()) {
+        if (formula.type === 'function') {
+          usedFormulas.add(formula.name)
         }
-        return usedFormulas
-      },
-    )
-
-    if (componentFormulaReferences.has(value.name)) {
-      return
+      }
     }
+    return usedFormulas
+  })
 
-    // TODO: Memoize similar to above. We need have a helper class `ToddleFormula` with `ToddleFormula.normalizeFormulas()`
-    for (const f of Object.values(files.formulas ?? {})) {
-      if (f.name === value.name) {
-        continue
-      }
+  if (componentFormulaReferences.has(value.name)) {
+    return true
+  }
 
-      // Check if the formula is used in the formula
-      if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
-        return
-      }
+  // TODO: Memoize similar to above. We need have a helper class `ToddleFormula` with `ToddleFormula.normalizeFormulas()`
+  for (const f of Object.values(files.formulas ?? {})) {
+    if (f.name === value.name) {
+      continue
     }
 
-    report(path)
-  },
+    // Check if the formula is used in the formula
+    if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
+      return true
+    }
+  }
+  return false
 }
 
 const checkArguments = (

package/src/types.d.ts

@@ -21,8 +21,10 @@ import type {
   Route,
   ToddleProject,
 } from '@nordcraft/ssr/dist/ssr.types'
+import type { LegacyActionRuleFix } from './rules/actions/legacyActionRule'
 import type { NoReferenceComponentRuleFix } from './rules/components/noReferenceComponentRule'
 import type { LegacyFormulaRuleFix } from './rules/formulas/legacyFormulaRule'
+import type { NoReferenceProjectFormulaRuleFix } from './rules/formulas/noReferenceProjectFormulaRule'
 
 type Code =
   | 'ambiguous style variable syntax'
@@ -311,7 +313,11 @@ export type NodeType =
   | ProjectRoute
   | StyleVariantNode
 
-type FixType = LegacyFormulaRuleFix | NoReferenceComponentRuleFix
+type FixType =
+  | LegacyFormulaRuleFix
+  | LegacyActionRuleFix
+  | NoReferenceComponentRuleFix
+  | NoReferenceProjectFormulaRuleFix
 
 export interface Rule<T = unknown, V = NodeType> {
   category: Category

package/src/util/helpers.ts

@@ -1,7 +1,10 @@
 import type {
   ActionModel,
+  CustomActionArgument,
+  CustomActionModel,
   ElementNodeModel,
 } from '@nordcraft/core/dist/component/component.types'
+import type { FunctionArgument } from '@nordcraft/core/dist/formula/formula'
 import { isDefined } from '@nordcraft/core/dist/utils/util'
 
 /**
@@ -44,7 +47,9 @@ export function shouldSearchExactPath({
   )
 }
 
-export const isLegacyAction = (model: ActionModel) => {
+export const isLegacyAction = (
+  model: ActionModel,
+): model is CustomActionModel => {
   switch (model.type) {
     case 'Custom':
     case undefined:
@@ -58,14 +63,11 @@ const LEGACY_CUSTOM_ACTIONS = new Set([
   'If',
   'PreventDefault',
   'StopPropagation',
-  'Copy To Clipboard',
   'CopyToClipboard',
   'UpdateVariable',
-  'Update Variable',
   'Update URL parameter',
   'updateUrlParameters',
   'UpdateQueryParam',
-  'Update Query',
   'Fetch',
   'SetTimeout',
   'SetInterval',
@@ -74,6 +76,7 @@ const LEGACY_CUSTOM_ACTIONS = new Set([
   'GoToURL',
   'TriggerEvent',
   'Set session cookies',
+  '@toddle/setSessionCookies',
 ])
 
 interface BaseInteractiveContent {
@@ -130,3 +133,24 @@ export const interactiveContentElementDefinition = (
     }
     return true
   })
+
+export const ARRAY_ARGUMENT_MAPPINGS = { List: 'Array' }
+export const PREDICATE_ARGUMENT_MAPPINGS = {
+  ...ARRAY_ARGUMENT_MAPPINGS,
+  'Predicate fx': 'Formula',
+}
+
+export const renameArguments = <
+  T extends FunctionArgument | CustomActionArgument,
+>(
+  mappings: Record<string, string>,
+  args: T[] | undefined,
+): T[] =>
+  args?.map((arg) => ({
+    ...arg,
+    // Let's adjust the names
+    name:
+      typeof arg.name === 'string'
+        ? (mappings[arg.name] ?? arg.name)
+        : arg.name,
+  })) ?? []