@nordcraft/search 1.0.45 → 1.0.47

package/src/rules/logic/noUnnecessaryConditionFalsy.ts

@@ -1,4 +1,5 @@
 import type { Rule } from '../../types'
+import { contextlessEvaluateFormula } from '../../util/contextlessEvaluateFormula'
 
 export const noUnnecessaryConditionFalsy: Rule = {
   code: 'no-unnecessary-condition-falsy',
@@ -10,10 +11,10 @@ export const noUnnecessaryConditionFalsy: Rule = {
     }
 
     if (
-      value.arguments.some(
-        (arg) =>
-          arg.formula.type === 'value' && Boolean(arg.formula.value) === false,
-      )
+      value.arguments.some((arg) => {
+        const { result, isStatic } = contextlessEvaluateFormula(arg.formula)
+        return isStatic && Boolean(result) === false
+      })
     ) {
       report(path)
     }

package/src/rules/logic/noUnnecessaryConditionTruthy.test.ts

@@ -32,7 +32,41 @@ describe('noUnnecessaryConditionTruthy', () => {
                         },
                       ],
                     },
-                    test2: {
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noUnnecessaryConditionTruthy],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-unnecessary-condition-truthy')
+  })
+
+  test('should report unnecessary truthy conditions when a value is of type object or array as they are always consider truthy', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test1: {
                       type: 'or',
                       arguments: [
                         {
@@ -43,7 +77,7 @@ describe('noUnnecessaryConditionTruthy', () => {
                         },
                       ],
                     },
-                    test3: {
+                    test2: {
                       type: 'or',
                       arguments: [
                         {
@@ -73,10 +107,9 @@ describe('noUnnecessaryConditionTruthy', () => {
       }),
     )
 
-    expect(problems).toHaveLength(3)
+    expect(problems).toHaveLength(2)
     expect(problems[0].code).toBe('no-unnecessary-condition-truthy')
     expect(problems[1].code).toBe('no-unnecessary-condition-truthy')
-    expect(problems[2].code).toBe('no-unnecessary-condition-truthy')
   })
 
   test('should not report necessary truthy conditions', () => {

package/src/rules/logic/noUnnecessaryConditionTruthy.ts

@@ -1,4 +1,5 @@
 import type { Rule } from '../../types'
+import { contextlessEvaluateFormula } from '../../util/contextlessEvaluateFormula'
 
 export const noUnnecessaryConditionTruthy: Rule = {
   code: 'no-unnecessary-condition-truthy',
@@ -10,14 +11,15 @@ export const noUnnecessaryConditionTruthy: Rule = {
     }
 
     if (
-      value.arguments.some(
-        (arg) =>
-          (arg.formula.type === 'value' &&
-            Boolean(arg.formula.value) === true) ||
-          // Objects and arrays, even empty ones, are always truthy
-          arg.formula.type === 'object' ||
-          arg.formula.type === 'array',
-      )
+      value.arguments.some((arg) => {
+        // Objects and arrays, even empty ones, are always truthy
+        if (arg.formula.type === 'object' || arg.formula.type === 'array') {
+          return true
+        }
+
+        const { result, isStatic } = contextlessEvaluateFormula(arg.formula)
+        return isStatic && Boolean(result) === true
+      })
     ) {
       report(path)
     }

package/src/rules/noReferenceNodeRule.test.ts

@@ -130,7 +130,7 @@ describe('fix noReferenceNodeRule', () => {
     const fixedFiles = fixProject({
       files,
       rule: noReferenceNodeRule,
-      fixType: 'delete orphan node',
+      fixType: 'delete-orphan-node',
     })
     expect(Object.keys(fixedFiles.components.test!.nodes)).toEqual([
       'root',

package/src/rules/noReferenceNodeRule.ts

@@ -6,22 +6,29 @@ export const noReferenceNodeRule: Rule<{ node: string }> = {
   level: 'warning',
   category: 'No References',
   visit: (report, args) => {
-    if (args.nodeType !== 'component') {
+    if (args.nodeType !== 'component-node') {
       return
     }
-    const { path, value: component } = args
-    const referencedNodes = new Set(
-      Object.values(component.nodes).flatMap((node) => node.children ?? []),
+    const { path, component } = args
+    const nodeId = path.at(-1)
+    if (typeof nodeId !== 'string') {
+      return
+    }
+    const referencedNodesInComponent = args.memo(
+      `node-references-${component.name}`,
+      () =>
+        new Set(
+          Object.values(component.nodes).flatMap((node) => node.children ?? []),
+        ),
     )
-    for (const key of Object.keys(component.nodes)) {
-      if (key !== 'root' && !referencedNodes.has(key)) {
-        report([...path, 'nodes', key], { node: key }, ['delete orphan node'])
-      }
+
+    if (nodeId !== 'root' && !referencedNodesInComponent.has(nodeId)) {
+      report(path, { node: nodeId }, ['delete-orphan-node'])
     }
   },
   fixes: {
-    'delete orphan node': removeFromPathFix,
+    'delete-orphan-node': removeFromPathFix,
   },
 }
 
-export type NoReferenceNodeRuleFix = 'delete orphan node'
+export type NoReferenceNodeRuleFix = 'delete-orphan-node'

package/src/rules/style/invalidStyleSyntaxRule.test.ts

@@ -92,7 +92,7 @@ describe('fix invalidStyleSyntaxRule', () => {
     const fixedFiles = fixProject({
       files,
       rule: invalidStyleSyntaxRule,
-      fixType: 'delete style property',
+      fixType: 'delete-style-property',
     })
     expect((fixedFiles.components.test!.nodes.root as ElementNodeModel).style)
       .toMatchInlineSnapshot(`

package/src/rules/style/invalidStyleSyntaxRule.ts

@@ -24,12 +24,12 @@ export const invalidStyleSyntaxRule: Rule<{
       },
     )
     if (!valid) {
-      report(path, { property: value.styleProperty }, ['delete style property'])
+      report(path, { property: value.styleProperty }, ['delete-style-property'])
     }
   },
   fixes: {
-    'delete style property': removeFromPathFix,
+    'delete-style-property': removeFromPathFix,
   },
 }
 
-export type InvalidStyleSyntaxRuleFix = 'delete style property'
+export type InvalidStyleSyntaxRuleFix = 'delete-style-property'

package/src/rules/workflows/noPostNavigateAction.test.ts

@@ -1,8 +1,11 @@
+import type { ElementNodeModel } from '@nordcraft/core/dist/component/component.types'
+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 { noPostNavigateAction } from './noPostNavigateAction'
 
-describe('noPostNavigateAction', () => {
+describe('find noPostNavigateAction', () => {
   test('should detect actions after a url navigate action', () => {
     const problems = Array.from(
       searchProject({
@@ -457,3 +460,110 @@ describe('noPostNavigateAction', () => {
     expect(problems).toHaveLength(0)
   })
 })
+
+describe('fix noPostNavigateAction', () => {
+  test('should remove actions after a url navigate action', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        nav: {
+          attributes: {},
+          events: [],
+          formulas: {},
+          nodes: {
+            root: {
+              type: 'element',
+              tag: 'div',
+              attrs: {},
+              classes: {},
+              events: {},
+              children: ['wkPXF99C3qdRgZmUcnHO_'],
+              style: {},
+            },
+            wkPXF99C3qdRgZmUcnHO_: {
+              tag: 'button',
+              type: 'element',
+              attrs: {},
+              style: {
+                color: 'var(--grey-200, #E5E5E5)',
+                'border-radius': '6px',
+                'background-color': 'var(--blue-600, #2563EB)',
+                'padding-left': '8px',
+                'padding-right': '8px',
+                'padding-top': '8px',
+                'padding-bottom': '8px',
+                width: 'fit-content',
+                cursor: 'pointer',
+              },
+              events: {
+                click: {
+                  trigger: 'click',
+                  actions: [
+                    {
+                      name: '@toddle/gotToURL',
+                      arguments: [
+                        {
+                          name: 'URL',
+                          formula: {
+                            type: 'value',
+                            value: 'https://example.com',
+                          },
+                        },
+                      ],
+                      label: 'Go to URL',
+                    },
+                    {
+                      name: '@toddle/logToConsole',
+                      arguments: [
+                        {
+                          name: 'Label',
+                          formula: {
+                            type: 'value',
+                            value: '',
+                          },
+                        },
+                        {
+                          name: 'Data',
+                          formula: {
+                            type: 'value',
+                            value: '<Data>',
+                          },
+                        },
+                      ],
+                      label: 'Log to console',
+                    },
+                  ],
+                },
+              },
+              classes: {},
+              children: ['zFhmZR6YnLy089HmlK-Yn'],
+              variants: [],
+            },
+            'zFhmZR6YnLy089HmlK-Yn': {
+              type: 'text',
+              value: {
+                type: 'value',
+                value: 'Button',
+              },
+            },
+          },
+          variables: {},
+          apis: {},
+          name: 'nav',
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files,
+      rule: noPostNavigateAction,
+      fixType: 'delete-following-actions',
+    })
+    expect(
+      (
+        fixedProject.components.nav?.nodes[
+          'wkPXF99C3qdRgZmUcnHO_'
+        ] as ElementNodeModel
+      )?.events?.click?.actions,
+    ).toHaveLength(1)
+  })
+})

package/src/rules/workflows/noPostNavigateAction.ts

@@ -1,5 +1,5 @@
-import { get } from '@nordcraft/core/dist/utils/collections'
-import type { Rule } from '../../types'
+import { get, set } from '@nordcraft/core/dist/utils/collections'
+import type { ActionModelNode, Rule } from '../../types'
 
 export const noPostNavigateAction: Rule<{ parameter: string }> = {
   code: 'no post navigate action',
@@ -25,7 +25,24 @@ export const noPostNavigateAction: Rule<{ parameter: string }> = {
     const actionIndex = Number(_actionIndex)
     if (actionIndex < actions.length - 1) {
       // If the action is not the last one in the array, report it
-      report(path)
+      report(path, undefined, ['delete-following-actions'])
     }
   },
+  fixes: {
+    'delete-following-actions': ({ path, files }: ActionModelNode) => {
+      const actionsArrayPath = path.slice(0, -1).map((p) => String(p))
+      const actions = get(files, actionsArrayPath)
+      const actionIndex = path.at(-1)
+      if (actionIndex === undefined || !Array.isArray(actions)) {
+        return
+      }
+      return set(
+        files,
+        actionsArrayPath,
+        actions.slice(0, Number(actionIndex) + 1),
+      )
+    },
+  },
 }
+
+export type NoPostNavigateActionRuleFix = 'delete-following-actions'

package/src/types.d.ts

@@ -25,13 +25,16 @@ import type { LegacyActionRuleFix } from './rules/actions/legacyActionRule'
 import type { NoReferenceProjectActionRuleFix } from './rules/actions/noReferenceProjectActionRule'
 import type { NoReferenceApiRuleFix } from './rules/apis/noReferenceApiRule'
 import type { NoReferenceAttributeRuleFix } from './rules/attributes/noReferenceAttributeRule'
+import type { UnknownComponentAttributeRuleFix } from './rules/attributes/unknownComponentAttributeRule'
 import type { NoReferenceComponentRuleFix } from './rules/components/noReferenceComponentRule'
 import type { NoReferenceEventRuleFix } from './rules/events/noReferenceEventRule'
 import type { LegacyFormulaRuleFix } from './rules/formulas/legacyFormulaRule'
 import type { NoReferenceComponentFormulaRuleFix } from './rules/formulas/noReferenceComponentFormulaRule'
 import type { NoReferenceProjectFormulaRuleFix } from './rules/formulas/noReferenceProjectFormulaRule'
+import type { NoStaticNodeConditionRuleFix } from './rules/logic/noStaticNodeCondition'
 import type { NoReferenceNodeRuleFix } from './rules/noReferenceNodeRule'
 import type { InvalidStyleSyntaxRuleFix } from './rules/style/invalidStyleSyntaxRule'
+import type { NoPostNavigateActionRuleFix } from './rules/workflows/noPostNavigateAction'
 
 type Code =
   | 'duplicate event trigger'
@@ -59,6 +62,7 @@ type Code =
   | 'no-reference project action'
   | 'no-reference project formula'
   | 'no-reference variable'
+  | 'no-static-node-condition'
   | 'no-unnecessary-condition-falsy'
   | 'no-unnecessary-condition-truthy'
   | 'non-empty void element'
@@ -73,6 +77,7 @@ type Code =
   | 'unknown api'
   | 'unknown attribute'
   | 'unknown classname'
+  | 'unknown component attribute'
   | 'unknown component formula input'
   | 'unknown component slot'
   | 'unknown context formula'
@@ -217,6 +222,10 @@ type ComponentWorkflowNode = {
           testValue: any
         }[]
       | null
+    callbacks?: {
+      name: string
+      testValue: any
+    }[]
     actions: ActionModel[]
     exposeInContext?: boolean | undefined
   }
@@ -343,6 +352,9 @@ type FixType =
   | NoReferenceComponentFormulaRuleFix
   | NoReferenceNodeRuleFix
   | InvalidStyleSyntaxRuleFix
+  | NoStaticNodeConditionRuleFix
+  | NoPostNavigateActionRuleFix
+  | UnknownComponentAttributeRuleFix
 
 export interface Rule<T = unknown, V = NodeType> {
   category: Category

package/src/util/contextlessEvaluateFormula.test.ts

@@ -0,0 +1,190 @@
+import { describe, expect, test } from 'bun:test'
+import { contextlessEvaluateFormula } from './contextlessEvaluateFormula'
+
+describe('contextlessEvaluateFormula', () => {
+  test('should return `true` when the formula is a simple value formula', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'value',
+        value: true,
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: true,
+    })
+  })
+
+  test('should not return a result and have `isStatic: false` when the formula uses a non-pure formula ("randomNumber", "Now")', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'apply',
+        name: 'randomNumber',
+        arguments: [],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: undefined,
+    })
+
+    expect(
+      contextlessEvaluateFormula({
+        type: 'apply',
+        name: 'now',
+        arguments: [],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: undefined,
+    })
+  })
+
+  test('should not return a result and have `isStatic: false` when the formula depends on a variable', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'path',
+        path: ['Variables', 'myVariable'],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: undefined,
+    })
+  })
+
+  test('should return a result and static for an array formula where all args are array or value types', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'array',
+        arguments: [
+          { formula: { type: 'value', value: 1 } },
+          {
+            formula: {
+              type: 'array',
+              arguments: [{ formula: { type: 'value', value: 2 } }],
+            },
+          },
+        ],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: [1, [2]],
+    })
+  })
+
+  test('should return `isStatic: false` for an array formula with a non-static argument', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'array',
+        arguments: [
+          { formula: { type: 'value', value: 1 } },
+          { formula: { type: 'apply', name: 'randomNumber', arguments: [] } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: [
+        1,
+        undefined, // The second argument was not static
+      ],
+    })
+  })
+
+  test('should be static true for `And` formulas with no arguments', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'and',
+        arguments: [],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: true,
+    })
+  })
+
+  test('should be static false for `Or` formulas with no arguments', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'or',
+        arguments: [],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: false,
+    })
+  })
+
+  test('should be static true for `And` formulas with all static truthy arguments', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'and',
+        arguments: [
+          { formula: { type: 'value', value: true } },
+          { formula: { type: 'value', value: true } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: true,
+    })
+  })
+
+  test('should not be static for `And` where any dynamic value exist', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'and',
+        arguments: [
+          { formula: { type: 'value', value: true } },
+          { formula: { type: 'apply', name: 'randomNumber', arguments: [] } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: undefined,
+    })
+  })
+
+  test('should be static false for `And` when any argument is static false, even when dynamic arguments exist', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'and',
+        arguments: [
+          { formula: { type: 'value', value: true } },
+          { formula: { type: 'path', path: ['Variables', 'myVariable'] } },
+          { formula: { type: 'value', value: false } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: false,
+    })
+  })
+
+  test('should not be static for `Or` when any argument is dynamic and all static are falsy', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'or',
+        arguments: [
+          { formula: { type: 'value', value: false } },
+          { formula: { type: 'apply', name: 'randomNumber', arguments: [] } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: false,
+      result: undefined,
+    })
+  })
+
+  test('should be static true for `Or` when any argument is static true, even when dynamic arguments exist', () => {
+    expect(
+      contextlessEvaluateFormula({
+        type: 'or',
+        arguments: [
+          { formula: { type: 'value', value: true } },
+          { formula: { type: 'apply', name: 'randomNumber', arguments: [] } },
+        ],
+      }),
+    ).toEqual({
+      isStatic: true,
+      result: true,
+    })
+  })
+})