@nordcraft/search 1.0.46 → 1.0.48

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/searchProject.ts

@@ -480,6 +480,30 @@ function* visitNode({
           state,
           fixOptions: fixOptions as any,
         })
+        if (
+          value.nodes[key].type === 'component' ||
+          value.nodes[key].type === 'element'
+        ) {
+          // Visit attributes on component and element nodes
+          for (const attrKey in value.nodes[key].attrs) {
+            const attr = value.nodes[key].attrs[attrKey]
+            yield* visitNode({
+              args: {
+                nodeType: 'component-node-attribute',
+                value: { key: attrKey, value: attr },
+                path: [...path, 'nodes', key, 'attrs', attrKey],
+                rules,
+                files,
+                pathsToVisit,
+                useExactPaths,
+                memo,
+                node: value.nodes[key],
+              },
+              state,
+              fixOptions: fixOptions as any,
+            })
+          }
+        }
       }
 
       for (const {

package/src/types.d.ts

@@ -6,6 +6,7 @@ import type {
   ComponentEvent as _ComponentEvent,
   ActionModel,
   Component,
+  ComponentNodeModel,
   ElementNodeModel,
   NodeModel,
   StyleVariant,
@@ -25,14 +26,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/noStaticNodeConditionRule'
+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'
@@ -75,6 +78,7 @@ type Code =
   | 'unknown api'
   | 'unknown attribute'
   | 'unknown classname'
+  | 'unknown component attribute'
   | 'unknown component formula input'
   | 'unknown component slot'
   | 'unknown context formula'
@@ -219,6 +223,10 @@ type ComponentWorkflowNode = {
           testValue: any
         }[]
       | null
+    callbacks?: {
+      name: string
+      testValue: any
+    }[]
     actions: ActionModel[]
     exposeInContext?: boolean | undefined
   }
@@ -248,6 +256,12 @@ type ComponentVariableNode = {
   component: ToddleComponent<Function>
 } & Base
 
+type ComponentNodeAttributeNode = {
+  nodeType: 'component-node-attribute'
+  value: { key: string; value?: Formula }
+  node: ComponentNodeModel | ElementNodeModel
+} & Base
+
 type ComponentAttributeNode = {
   nodeType: 'component-attribute'
   value: Component['attributes'][0]
@@ -320,6 +334,7 @@ export type NodeType =
   | ComponentEvent
   | ComponentFormulaNode
   | ComponentNode
+  | ComponentNodeAttributeNode
   | ComponentNodeNode
   | ComponentVariableNode
   | ComponentWorkflowNode
@@ -328,8 +343,8 @@ export type NodeType =
   | ProjectApiService
   | ProjectConfigNode
   | ProjectFormulaNode
-  | ProjectThemeNode
   | ProjectRoute
+  | ProjectThemeNode
   | StyleNode
   | StyleVariantNode
 
@@ -346,6 +361,8 @@ type FixType =
   | NoReferenceNodeRuleFix
   | InvalidStyleSyntaxRuleFix
   | NoStaticNodeConditionRuleFix
+  | NoPostNavigateActionRuleFix
+  | UnknownComponentAttributeRuleFix
 
 export interface Rule<T = unknown, V = NodeType> {
   category: Category

package/src/util/helpers.test.ts

@@ -53,7 +53,7 @@ describe('shouldSearchPath', () => {
 })
 
 describe('shouldSearchExactPath', () => {
-  test.only('should only return true for exact matches', () => {
+  test('should only return true for exact matches', () => {
     const pathsToVisit = [
       ['components', 'Button'],
       ['components', 'Input'],

package/src/util/removeUnused.fix.ts

@@ -6,28 +6,41 @@ export const removeFromPathFix: FixFunction<NodeType> = ({ path, files }) =>
   omit(files, path)
 
 /**
- * Same as removeFromPathFix, but also removes the node from its parent's children.
+ * Same as removeFromPathFix, but also cleans up any references to the removed node.
  */
 export const removeNodeFromPathFix: FixFunction<NodeType> = (data) => {
   if (data.nodeType !== 'component-node') {
     throw new Error('removeNodeFromPathFix can only be used on component nodes')
   }
 
-  const componentNodesPath = data.path.slice(0, -1).map(String)
-  const filesWithoutNode = removeFromPathFix(data)
-  const nodes = get(filesWithoutNode, componentNodesPath) as Record<
-    string,
-    NodeModel
-  >
+  const componentNodesPath = data.path.map(String)
+  const nodeId = componentNodesPath.pop()!
+  const nodes = get(data.files, componentNodesPath) as Record<string, NodeModel>
+
+  // Clean parent reference
   for (const key in nodes) {
-    if (
-      nodes[key].children?.includes(data.path[data.path.length - 1] as string)
-    ) {
-      nodes[key].children = nodes[key].children.filter(
-        (p) => p !== data.path[data.path.length - 1],
-      )
+    if (nodes[key].children?.includes(nodeId)) {
+      nodes[key].children = nodes[key].children.filter((p) => p !== nodeId)
+    }
+  }
+
+  // Clean children recursively
+  const removeNodeAndChildren = (nodeId: string) => {
+    const node = nodes[nodeId] as NodeModel | undefined
+    if (!node) {
+      return
     }
+
+    if (node.children) {
+      for (const childId of node.children) {
+        removeNodeAndChildren(childId)
+      }
+    }
+
+    delete nodes[nodeId]
   }
 
-  return set(filesWithoutNode, componentNodesPath, nodes)
+  removeNodeAndChildren(nodeId)
+
+  return set(data.files, componentNodesPath, nodes)
 }