@nordcraft/search 1.0.52 → 1.0.54

package/src/rules/issues/formulas/unknownRepeatItemFormulaRule.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownRepeatItemFormulaRule } from './unknownRepeatItemFormulaRule'
+
+describe('unknownRepeatItemFormulaRule', () => {
+  test('should find unknown repeat item formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                '84CPDAaFJdwh8Vaimehky': {
+                  type: 'text',
+                  value: {
+                    type: 'path',
+                    path: ['ListItem', 'Item'],
+                  },
+                },
+                'Z95Ucsbip-YWbTmC38-vG': {
+                  tag: 'li',
+                  type: 'element',
+                  attrs: {},
+                  style: {
+                    'font-weight': 'var(--font-weight-regular)',
+                    'justify-content': 'center',
+                  },
+                  events: {},
+                  classes: {},
+                  children: ['84CPDAaFJdwh8Vaimehky'],
+                },
+                root: {
+                  tag: 'ul',
+                  type: 'element',
+                  attrs: {},
+                  style: {
+                    gap: '8px',
+                    width: '100%',
+                  },
+                  events: {},
+                  classes: {},
+                  children: ['Z95Ucsbip-YWbTmC38-vG'],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownRepeatItemFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat item formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      '84CPDAaFJdwh8Vaimehky',
+      'value',
+    ])
+  })
+  test('should ignore known repeat item formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                '84CPDAaFJdwh8Vaimehky': {
+                  type: 'text',
+                  value: {
+                    type: 'path',
+                    path: ['ListItem', 'Item'],
+                  },
+                },
+                'Z95Ucsbip-YWbTmC38-vG': {
+                  tag: 'li',
+                  type: 'element',
+                  attrs: {},
+                  style: {
+                    'font-weight': 'var(--font-weight-regular)',
+                    'justify-content': 'center',
+                  },
+                  events: {},
+                  classes: {},
+                  children: ['84CPDAaFJdwh8Vaimehky'],
+                  repeat: {
+                    type: 'array',
+                    arguments: [
+                      {
+                        formula: {
+                          type: 'value',
+                          value: 0,
+                        },
+                      },
+                      {
+                        formula: {
+                          type: 'value',
+                          value: 1,
+                        },
+                      },
+                    ],
+                  },
+                },
+                root: {
+                  tag: 'ul',
+                  type: 'element',
+                  attrs: {},
+                  style: {
+                    gap: '8px',
+                    width: '100%',
+                  },
+                  events: {},
+                  classes: {},
+                  children: ['Z95Ucsbip-YWbTmC38-vG'],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownRepeatItemFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/formulas/unknownRepeatItemFormulaRule.ts

@@ -0,0 +1,46 @@
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import type { Rule } from '../../../types'
+
+export const unknownRepeatItemFormulaRule: Rule = {
+  code: 'unknown repeat item formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path?.[0] !== 'ListItem' ||
+      value.path?.[1] !== 'Item' ||
+      path.length < 3 ||
+      path[0] !== 'components' ||
+      path[2] !== 'nodes'
+    ) {
+      return
+    }
+    const [_components, componentName, _nodes, nodeId] = path as string[]
+    const component = files.components[componentName]
+    if (!component) {
+      return
+    }
+    const findParentWithRepeat = (
+      args: [id: string, node: NodeModel] | undefined,
+    ): NodeModel | undefined => {
+      if (!args) {
+        return
+      }
+      const [id, node] = args
+      if (node.repeat) {
+        return node
+      }
+      const parent = Object.entries(component.nodes).find(([_, node]) =>
+        node.children?.includes(id),
+      )
+      return findParentWithRepeat(parent)
+    }
+    const node = component.nodes[nodeId]
+    const parentWithRepeat = findParentWithRepeat([nodeId, node])
+    if (!parentWithRepeat) {
+      report(path)
+    }
+  },
+}

package/src/rules/issues/issueRules.index.ts

@@ -0,0 +1,34 @@
+import type { Rule } from '../../types'
+import actionRules from './actions/actionRules.index'
+import apiRules from './apis/apiRules.index'
+import attributeRules from './attributes/attributeRules.index'
+import componentRules from './components/componentRules.index'
+import contextRules from './context/contextRules.index'
+import domRules from './dom/domRules.index'
+import eventRules from './events/eventRules.index'
+import formulaRules from './formulas/formulaRules.index'
+import logicRules from './logic/logicRules.index'
+import miscRules from './miscellaneous/miscRules.index'
+import routingRules from './routing/routingRules.index'
+import slotRules from './slots/slotRules.index'
+import styleRules from './style/styleRules.index'
+import variableRules from './variables/variableRules.index'
+import workflowRules from './workflows/workflowRules.index'
+
+export const ISSUE_RULES: Rule[] = [
+  ...actionRules,
+  ...apiRules,
+  ...attributeRules,
+  ...componentRules,
+  ...contextRules,
+  ...domRules,
+  ...eventRules,
+  ...formulaRules,
+  ...logicRules,
+  ...miscRules,
+  ...routingRules,
+  ...slotRules,
+  ...styleRules,
+  ...variableRules,
+  ...workflowRules,
+]

package/src/rules/issues/logic/logicRules.index.ts

@@ -0,0 +1,17 @@
+import { unknownFormulaRule } from '../formulas/unknownFormulaRule'
+import { unknownProjectFormulaRule } from '../formulas/unknownProjectFormulaRule'
+import { unknownRepeatIndexFormulaRule } from '../formulas/unknownRepeatIndexFormulaRule'
+import { unknownRepeatItemFormulaRule } from '../formulas/unknownRepeatItemFormulaRule'
+import { noStaticNodeCondition } from './noStaticNodeCondition'
+import { noUnnecessaryConditionFalsy } from './noUnnecessaryConditionFalsy'
+import { noUnnecessaryConditionTruthy } from './noUnnecessaryConditionTruthy'
+
+export default [
+  noStaticNodeCondition,
+  noUnnecessaryConditionFalsy,
+  noUnnecessaryConditionTruthy,
+  unknownFormulaRule,
+  unknownProjectFormulaRule,
+  unknownRepeatIndexFormulaRule,
+  unknownRepeatItemFormulaRule,
+]

package/src/rules/issues/logic/noStaticNodeCondition.test.ts

@@ -0,0 +1,310 @@
+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 { noStaticNodeCondition } from './noStaticNodeCondition'
+
+describe('noStaticNodeCondition', () => {
+  test('should report node condition that is always truthy', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  condition: {
+                    type: 'value',
+                    value: true,
+                  },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noStaticNodeCondition],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-static-node-condition')
+    expect(problems[0].details).toEqual({
+      result: true,
+    })
+    expect(problems[0].fixes).toEqual(['remove-condition'])
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'condition',
+    ])
+  })
+
+  test('should report node condition that is always falsy', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  condition: {
+                    type: 'value',
+                    value: false,
+                  },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noStaticNodeCondition],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-static-node-condition')
+    expect(problems[0].details).toEqual({
+      result: false,
+    })
+  })
+
+  test('should not report node condition that is dynamic', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  condition: {
+                    type: 'apply',
+                    name: 'randomNumber',
+                    arguments: [],
+                  },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noStaticNodeCondition],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+
+  test('should fix static truthy condition by removing the condition', () => {
+    const files: ProjectFiles = {
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: [],
+              style: {},
+              condition: {
+                type: 'value',
+                value: true,
+              },
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const filesClone = structuredClone(files)
+    const fixedFiles = fixProject({
+      files,
+      rule: noStaticNodeCondition,
+      fixType: 'remove-condition',
+      pathsToVisit: [['components', 'test', 'nodes', 'root', 'condition']],
+    })
+    expect(fixedFiles).toEqual({
+      components: {
+        test: {
+          apis: {},
+          attributes: {},
+          formulas: {},
+          name: 'test',
+          nodes: {
+            root: {
+              attrs: {},
+              children: [],
+              classes: {},
+              events: {},
+              style: {},
+              tag: 'div',
+              type: 'element',
+            },
+          },
+          variables: {},
+        },
+      },
+    })
+
+    // Also ensure that the original files are not mutated
+    expect(files).toEqual(filesClone)
+  })
+
+  test('should fix static falsy condition by removing the node and any references to it', () => {
+    const files: ProjectFiles = {
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: ['alwaysHiddenElement', 'sometimesVisibleElement'],
+              style: {},
+            },
+            alwaysHiddenElement: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: ['child'],
+              style: {},
+              condition: {
+                type: 'value',
+                value: false,
+              },
+            },
+            sometimesVisibleElement: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: [],
+              style: {},
+              condition: {
+                type: 'path',
+                path: ['Variables', 'maybe'],
+              },
+            },
+            child: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: ['childsChild'],
+              style: {},
+            },
+            childsChild: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: [],
+              style: {},
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const filesClone = structuredClone(files)
+    const fixedFiles = fixProject({
+      files,
+      rule: noStaticNodeCondition,
+      fixType: 'remove-node',
+      pathsToVisit: [
+        ['components', 'test', 'nodes', 'alwaysHiddenElement', 'condition'],
+      ],
+    })
+
+    expect(fixedFiles).toEqual({
+      components: {
+        test: {
+          apis: {},
+          attributes: {},
+          formulas: {},
+          name: 'test',
+          nodes: {
+            root: {
+              attrs: {},
+              children: ['sometimesVisibleElement'],
+              classes: {},
+              events: {},
+              style: {},
+              tag: 'div',
+              type: 'element',
+            },
+            sometimesVisibleElement: {
+              attrs: {},
+              children: [],
+              classes: {},
+              condition: {
+                path: ['Variables', 'maybe'],
+                type: 'path',
+              },
+              events: {},
+              style: {},
+              tag: 'div',
+              type: 'element',
+            },
+          },
+          variables: {},
+        },
+      },
+    })
+
+    // Also ensure that the original files are not mutated
+    expect(files).toEqual(filesClone)
+  })
+})

package/src/rules/issues/logic/noStaticNodeCondition.ts

@@ -0,0 +1,50 @@
+import type { FixFunction, NodeType, Rule } from '../../../types'
+import { contextlessEvaluateFormula } from '../../../util/contextlessEvaluateFormula'
+import {
+  removeFromPathFix,
+  removeNodeFromPathFix,
+} from '../../../util/removeUnused.fix'
+
+export const noStaticNodeCondition: Rule<{
+  result: ReturnType<typeof contextlessEvaluateFormula>['result']
+}> = {
+  code: 'no-static-node-condition',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      !(
+        path.length === 5 &&
+        path[0] === 'components' &&
+        path[2] === 'nodes' &&
+        path[4] === 'condition'
+      )
+    ) {
+      return
+    }
+
+    const { isStatic, result } = contextlessEvaluateFormula(value)
+    if (isStatic) {
+      // - if truthy: "Condition is always true, you can safely remove the condition as it will always be rendered."
+      // - if falsy: "Condition is always false, you can safely remove the entire node as it will never be rendered."
+      report(
+        path,
+        {
+          result,
+        },
+        Boolean(result) === true ? ['remove-condition'] : ['remove-node'],
+      )
+    }
+  },
+  fixes: {
+    'remove-condition': removeFromPathFix,
+    'remove-node': (({ path, ...data }) =>
+      removeNodeFromPathFix({
+        path: path.slice(0, -1),
+        ...data,
+      })) as FixFunction<NodeType>,
+  },
+}
+
+export type NoStaticNodeConditionRuleFix = 'remove-condition' | 'remove-node'

package/src/rules/issues/logic/noUnnecessaryConditionFalsy.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { noUnnecessaryConditionFalsy } from './noUnnecessaryConditionFalsy'
+
+describe('noUnnecessaryConditionFalsy', () => {
+  test('should report unnecessary truthy conditions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: {
+                      type: 'and',
+                      arguments: [
+                        {
+                          formula: {
+                            type: 'apply',
+                            name: 'other',
+                            arguments: [],
+                          },
+                        },
+                        {
+                          formula: {
+                            type: 'value',
+                            value: false,
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noUnnecessaryConditionFalsy],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-unnecessary-condition-falsy')
+  })
+
+  test('should not report necessary truthy conditions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: {
+                      type: 'or',
+                      arguments: [
+                        {
+                          formula: {
+                            type: 'apply',
+                            name: 'other',
+                            arguments: [],
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noUnnecessaryConditionFalsy],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})