@nordcraft/search 1.0.44 → 1.0.46

package/src/rules/noReferenceNodeRule.test.ts

@@ -0,0 +1,140 @@
+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 { noReferenceNodeRule } from './noReferenceNodeRule'
+
+describe('find noReferenceNodeRule', () => {
+  test('should detect nodes with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  id: 'root',
+                  type: 'element',
+                  tag: 'div',
+                  children: [],
+                  attrs: {},
+                  style: {},
+                  events: {},
+                  classes: {},
+                },
+                '1LisbD0eCjsuccoUwajn1': {
+                  id: 'XdhwPGsdFNI4s8A0oMwre',
+                  type: 'text',
+                  value: { type: 'value', value: 'Clone the project' },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceNodeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].details).toEqual({ node: '1LisbD0eCjsuccoUwajn1' })
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      '1LisbD0eCjsuccoUwajn1',
+    ])
+  })
+
+  test('should not detect nodes with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  id: 'root',
+                  type: 'element',
+                  tag: 'div',
+                  children: ['1LisbD0eCjsuccoUwajn1'],
+                  attrs: {},
+                  style: {},
+                  events: {},
+                  classes: {},
+                },
+                '1LisbD0eCjsuccoUwajn1': {
+                  id: 'XdhwPGsdFNI4s8A0oMwre',
+                  type: 'text',
+                  value: { type: 'value', value: 'Clone the project' },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceNodeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})
+
+describe('fix noReferenceNodeRule', () => {
+  test('should delete nodes with no references', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              id: 'root',
+              type: 'element',
+              tag: 'div',
+              children: ['used'],
+              attrs: {},
+              style: {},
+              events: {},
+              classes: {},
+            },
+            '1LisbD0eCjsuccoUwajn1': {
+              id: 'XdhwPGsdFNI4s8A0oMwre',
+              type: 'text',
+              value: { type: 'value', value: 'Clone the project' },
+            },
+            used: {
+              id: 'used',
+              type: 'text',
+              value: { type: 'value', value: 'I am used' },
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: noReferenceNodeRule,
+      fixType: 'delete-orphan-node',
+    })
+    expect(Object.keys(fixedFiles.components.test!.nodes)).toEqual([
+      'root',
+      'used',
+    ])
+  })
+})

package/src/rules/noReferenceNodeRule.ts

@@ -0,0 +1,34 @@
+import type { Rule } from '../types'
+import { removeFromPathFix } from '../util/removeUnused.fix'
+
+export const noReferenceNodeRule: Rule<{ node: string }> = {
+  code: 'no-reference node',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component-node') {
+      return
+    }
+    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 ?? []),
+        ),
+    )
+
+    if (nodeId !== 'root' && !referencedNodesInComponent.has(nodeId)) {
+      report(path, { node: nodeId }, ['delete-orphan-node'])
+    }
+  },
+  fixes: {
+    'delete-orphan-node': removeFromPathFix,
+  },
+}
+
+export type NoReferenceNodeRuleFix = 'delete-orphan-node'

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

@@ -0,0 +1,106 @@
+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 { invalidStyleSyntaxRule } from './invalidStyleSyntaxRule'
+
+describe('find invalidStyleSyntaxRule', () => {
+  test('should find invalid style syntax', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  tag: 'ul',
+                  type: 'element',
+                  attrs: {},
+                  style: {
+                    gap: '8px',
+                    width: '100%',
+                    'max-width': 'calc(NOT VALID',
+                    height: '/* 100px */ 22px',
+                    '{': '100px',
+                    'border-width': '--my-var',
+                  },
+                  events: {},
+                  classes: {},
+                  children: [],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [invalidStyleSyntaxRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('invalid style syntax')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'style',
+      'max-width',
+    ])
+    expect(problems[0].details.property).toBe('max-width')
+    expect(problems[1].details.property).toBe('{')
+  })
+})
+
+describe('fix invalidStyleSyntaxRule', () => {
+  test('should remove an invalid style property', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              tag: 'ul',
+              type: 'element',
+              attrs: {},
+              style: {
+                gap: '8px',
+                width: '100%',
+                'max-width': 'calc(NOT VALID',
+                height: '/* 100px */ 22px',
+                '{': '100px',
+              },
+              events: {},
+              classes: {},
+              children: [],
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: invalidStyleSyntaxRule,
+      fixType: 'delete-style-property',
+    })
+    expect((fixedFiles.components.test!.nodes.root as ElementNodeModel).style)
+      .toMatchInlineSnapshot(`
+      {
+        "gap": "8px",
+        "height": "/* 100px */ 22px",
+        "width": "100%",
+      }
+    `)
+  })
+})

package/src/rules/style/invalidStyleSyntaxRule.ts

@@ -0,0 +1,35 @@
+import { parse } from 'postcss'
+import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
+
+export const invalidStyleSyntaxRule: Rule<{
+  property: string
+}> = {
+  code: 'invalid style syntax',
+  level: 'error',
+  category: 'Quality',
+  visit: (report, { nodeType, value, path, memo }) => {
+    if (nodeType !== 'style-declaration') {
+      return
+    }
+    const valid = memo(
+      `valid-style-${value.styleProperty}:${value.styleValue}`,
+      () => {
+        try {
+          parse(`${value.styleProperty}: ${value.styleValue}`)
+          return true
+        } catch {
+          return false
+        }
+      },
+    )
+    if (!valid) {
+      report(path, { property: value.styleProperty }, ['delete-style-property'])
+    }
+  },
+  fixes: {
+    'delete-style-property': removeFromPathFix,
+  },
+}
+
+export type InvalidStyleSyntaxRuleFix = 'delete-style-property'

package/src/searchProject.ts

@@ -262,7 +262,12 @@ function* visitNode({
               // The rule must have an implementation for the fix
               rule.fixes?.[fixOptions.fixType]
             ) {
-              const ruleFixes = rule.fixes[fixOptions.fixType]?.(data, state)
+              const ruleFixes = rule.fixes[fixOptions.fixType]?.(
+                // We must use the path from the report, not the original path
+                // because the report might be for a subpath
+                { ...data, path },
+                state,
+              )
               if (ruleFixes) {
                 fixedFiles = ruleFixes
               }
@@ -571,6 +576,25 @@ function* visitNode({
             })
           }
         }
+        for (const [styleKey, styleValue] of Object.entries(
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          value.style ?? {},
+        )) {
+          yield* visitNode({
+            args: {
+              nodeType: 'style-declaration',
+              value: { styleProperty: styleKey, styleValue, element: value },
+              path: [...path, 'style', styleKey],
+              rules,
+              files,
+              pathsToVisit,
+              useExactPaths,
+              memo,
+            },
+            state,
+            fixOptions: fixOptions as any,
+          })
+        }
       }
       break
 

package/src/types.d.ts

@@ -14,9 +14,9 @@ import type { ToddleComponent } from '@nordcraft/core/dist/component/ToddleCompo
 import type { Formula } from '@nordcraft/core/dist/formula/formula'
 import type { PluginFormula } from '@nordcraft/core/dist/formula/formulaTypes'
 import type { Theme } from '@nordcraft/core/dist/styling/theme'
+import type { PluginAction } from '@nordcraft/core/dist/types'
 import type {
   ApiService,
-  PluginAction,
   ProjectFiles,
   Route,
   ToddleProject,
@@ -30,9 +30,11 @@ import type { NoReferenceEventRuleFix } from './rules/events/noReferenceEventRul
 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 { NoReferenceNodeRuleFix } from './rules/noReferenceNodeRule'
+import type { InvalidStyleSyntaxRuleFix } from './rules/style/invalidStyleSyntaxRule'
 
 type Code =
-  | 'ambiguous style variable syntax'
   | 'duplicate event trigger'
   | 'duplicate url parameter'
   | 'duplicate workflow parameter'
@@ -40,6 +42,7 @@ type Code =
   | 'invalid api parser mode'
   | 'invalid api proxy body setting'
   | 'invalid element child'
+  | 'invalid style syntax'
   | 'legacy action'
   | 'legacy api'
   | 'legacy formula'
@@ -53,9 +56,11 @@ type Code =
   | 'no-reference component workflow'
   | 'no-reference component'
   | 'no-reference event'
+  | 'no-reference node'
   | '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'
@@ -297,6 +302,15 @@ type StyleVariantNode = {
   value: { variant: StyleVariant; element: ElementNodeModel }
 } & Base
 
+type StyleNode = {
+  nodeType: 'style-declaration'
+  value: {
+    styleProperty: string
+    styleValue: string
+    element: ElementNodeModel
+  }
+} & Base
+
 export type NodeType =
   | ActionModelNode
   | ComponentAPIInputNode
@@ -316,6 +330,7 @@ export type NodeType =
   | ProjectFormulaNode
   | ProjectThemeNode
   | ProjectRoute
+  | StyleNode
   | StyleVariantNode
 
 type FixType =
@@ -328,6 +343,9 @@ type FixType =
   | NoReferenceAttributeRuleFix
   | NoReferenceEventRuleFix
   | NoReferenceComponentFormulaRuleFix
+  | NoReferenceNodeRuleFix
+  | InvalidStyleSyntaxRuleFix
+  | NoStaticNodeConditionRuleFix
 
 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,
+    })
+  })
+})