@nordcraft/search 1.0.44 → 1.0.46

package/dist/util/removeUnused.fix.js

@@ -1,3 +1,20 @@
-import { omit } from '@nordcraft/core/dist/utils/collections';
+import { get, omit, set } from '@nordcraft/core/dist/utils/collections';
 export const removeFromPathFix = ({ path, files }) => omit(files, path);
+/**
+ * Same as removeFromPathFix, but also removes the node from its parent's children.
+ */
+export const removeNodeFromPathFix = (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);
+    for (const key in nodes) {
+        if (nodes[key].children?.includes(data.path[data.path.length - 1])) {
+            nodes[key].children = nodes[key].children.filter((p) => p !== data.path[data.path.length - 1]);
+        }
+    }
+    return set(filesWithoutNode, componentNodesPath, nodes);
+};
 //# sourceMappingURL=removeUnused.fix.js.map

package/dist/util/removeUnused.fix.js.map

@@ -1 +1 @@
-{"version":3,"file":"removeUnused.fix.js","sourceRoot":"","sources":["../../src/util/removeUnused.fix.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,wCAAwC,CAAA;AAG7D,MAAM,CAAC,MAAM,iBAAiB,GAA0B,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAC1E,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA"}
+{"version":3,"file":"removeUnused.fix.js","sourceRoot":"","sources":["../../src/util/removeUnused.fix.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,wCAAwC,CAAA;AAGvE,MAAM,CAAC,MAAM,iBAAiB,GAA0B,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,CAC1E,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;AAEnB;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAA0B,CAAC,IAAI,EAAE,EAAE;IACnE,IAAI,IAAI,CAAC,QAAQ,KAAK,gBAAgB,EAAE,CAAC;QACvC,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAA;IAC9E,CAAC;IAED,MAAM,kBAAkB,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7D,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA;IAChD,MAAM,KAAK,GAAG,GAAG,CAAC,gBAAgB,EAAE,kBAAkB,CAGrD,CAAA;IACD,KAAK,MAAM,GAAG,IAAI,KAAK,EAAE,CAAC;QACxB,IACE,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAW,CAAC,EACxE,CAAC;YACD,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAC9C,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAC7C,CAAA;QACH,CAAC;IACH,CAAC;IAED,OAAO,GAAG,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,KAAK,CAAC,CAAA;AACzD,CAAC,CAAA"}

package/package.json

@@ -5,8 +5,9 @@
 "license": "Apache-2.0",
 "homepage": "https://github.com/nordcraftengine/nordcraft",
 "dependencies": {
-"@nordcraft/ssr": "1.0.44",
-"jsondiffpatch": "0.7.3"
+"@nordcraft/ssr": "1.0.46",
+"jsondiffpatch": "0.7.3",
+"postcss": "8.5.6"
 },
 "scripts": {
 "build": "tsc",
@@ -18,5 +19,5 @@
 "test:watch:only": "bun test --watch --only"
 },
 "files": ["dist", "src"],
-"version": "1.0.44"
+"version": "1.0.46"
 }

package/src/problems.worker.ts

@@ -37,12 +37,14 @@ import { unknownFormulaRule } from './rules/formulas/unknownFormulaRule'
 import { unknownProjectFormulaRule } from './rules/formulas/unknownProjectFormulaRule'
 import { unknownRepeatIndexFormulaRule } from './rules/formulas/unknownRepeatIndexFormulaRule'
 import { unknownRepeatItemFormulaRule } from './rules/formulas/unknownRepeatItemFormulaRule'
+import { noStaticNodeCondition } from './rules/logic/noStaticNodeCondition'
 import { noUnnecessaryConditionFalsy } from './rules/logic/noUnnecessaryConditionFalsy'
 import { noUnnecessaryConditionTruthy } from './rules/logic/noUnnecessaryConditionTruthy'
+import { noReferenceNodeRule } from './rules/noReferenceNodeRule'
 import { requireExtensionRule } from './rules/requireExtensionRule'
 import { unknownClassnameRule } from './rules/slots/unknownClassnameRule'
 import { unknownComponentSlotRule } from './rules/slots/unknownComponentSlotRule'
-import { ambiguousStyleVariableSyntaxRule } from './rules/style-variables/ambiguousStyleVariableSyntaxRule'
+import { invalidStyleSyntaxRule } from './rules/style/invalidStyleSyntaxRule'
 import { unknownCookieRule } from './rules/unknownCookieRule'
 import { duplicateUrlParameterRule } from './rules/urlParameters/duplicateUrlParameterRule'
 import { unknownSetUrlParameterRule } from './rules/urlParameters/unknownSetUrlParameterRule'
@@ -144,6 +146,7 @@ const RULES = [
   duplicateWorkflowParameterRule,
   elementWithoutInteractiveContentRule,
   imageWithoutDimensionRule,
+  invalidStyleSyntaxRule,
   legacyActionRule,
   legacyApiRule,
   legacyFormulaRule,
@@ -156,9 +159,11 @@ const RULES = [
   noReferenceComponentRule,
   noReferenceComponentWorkflowRule,
   noReferenceEventRule,
+  noReferenceNodeRule,
   noReferenceProjectActionRule,
   noReferenceProjectFormulaRule,
   noReferenceVariableRule,
+  noStaticNodeCondition,
   noUnnecessaryConditionFalsy,
   noUnnecessaryConditionTruthy,
   requireExtensionRule,
@@ -190,25 +195,28 @@ const RULES = [
   unknownVariableRule,
   unknownVariableSetterRule,
   unknownWorkflowParameterRule,
-  ambiguousStyleVariableSyntaxRule,
 ]
 
 interface FindProblemsArgs {
+  id: string
   files: ProjectFiles
   options?: Options
 }
 
 interface FixProblemsArgs {
+  id: string
   files: ProjectFiles
   options?: Options
   fixRule: Code
   fixType: FixType
-  id: string
 }
 
 type Message = FindProblemsArgs | FixProblemsArgs
 
-type FindProblemsResponse = Result[]
+interface FindProblemsResponse {
+  id: string
+  results: Result[]
+}
 
 interface FixProblemsResponse {
   id: string
@@ -223,6 +231,11 @@ const respond = (data: Response) => postMessage(data)
 
 const findProblems = (data: FindProblemsArgs) => {
   const { files, options = {} } = data
+  const idRespond = (results: Result[]) =>
+    respond({
+      id: data.id,
+      results,
+    })
   const rules = RULES.filter(
     (rule) =>
       (!options.categories || options.categories.includes(rule.category)) &&
@@ -248,7 +261,7 @@ const findProblems = (data: FindProblemsArgs) => {
       case 'per-file': {
         if (fileType !== problem.path[0] || fileName !== problem.path[1]) {
           if (batch.length > 0) {
-            respond(batch)
+            idRespond(batch)
           }
           batch = []
           fileType = problem.path[0]
@@ -262,7 +275,7 @@ const findProblems = (data: FindProblemsArgs) => {
       default: {
         batch.push(problem)
         if (batch.length >= (options.batchSize ?? 1)) {
-          respond(batch)
+          idRespond(batch)
           batch = []
         }
         break
@@ -271,7 +284,7 @@ const findProblems = (data: FindProblemsArgs) => {
   }
 
   // Send the remaining results
-  respond(batch)
+  idRespond(batch)
 }
 
 const fixProblems = (data: FixProblemsArgs) => {

package/src/rules/actions/legacyActionRule.test.ts

@@ -197,7 +197,7 @@ describe('fix legacyActions', () => {
     })
     const fixedAction = (
       fixedProject.components['apiComponent']?.nodes['root'] as ElementNodeModel
-    ).events['click'].actions[0]
+    ).events['click']?.actions[0]
     expect(fixedAction).toMatchInlineSnapshot(`
       {
         "cases": [
@@ -321,7 +321,7 @@ describe('fix legacyActions', () => {
     })
     const fixedAction = (
       fixedProject.components['apiComponent']?.nodes['root'] as ElementNodeModel
-    ).events['click'].actions[0]
+    ).events['click']?.actions[0]
     expect(fixedAction).toMatchInlineSnapshot(`
       {
         "data": {
@@ -378,7 +378,7 @@ describe('fix legacyActions', () => {
     })
     const fixedAction = (
       fixedProject.components['apiComponent']?.nodes['root'] as ElementNodeModel
-    ).events['click'].actions[0]
+    ).events['click']?.actions[0]
     expect(fixedAction).toMatchInlineSnapshot(`
       {
         "arguments": [

package/src/rules/events/duplicateEventTriggerRule.ts

@@ -10,8 +10,9 @@ export const duplicateEventTriggerRule: Rule<{ trigger: string }> = {
     }
     const eventTriggers = new Set<string>()
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     Object.entries(value.events ?? {}).forEach(([key, event]) => {
-      if (typeof event.trigger !== 'string') {
+      if (typeof event?.trigger !== 'string') {
         return
       }
       if (eventTriggers.has(event.trigger)) {

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

@@ -0,0 +1,290 @@
+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 fixedFiles = fixProject({
+      files,
+      rule: noStaticNodeCondition,
+      fixType: 'remove-condition',
+    })
+    expect(fixedFiles).toMatchInlineSnapshot(`
+      {
+        "components": {
+          "test": {
+            "apis": {},
+            "attributes": {},
+            "formulas": {},
+            "name": "test",
+            "nodes": {
+              "root": {
+                "attrs": {},
+                "children": [],
+                "classes": {},
+                "events": {},
+                "style": {},
+                "tag": "div",
+                "type": "element",
+              },
+            },
+            "variables": {},
+          },
+        },
+      }
+    `)
+  })
+
+  test("should fix static falsy condition by removing the node and any parents' 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: [],
+              style: {},
+              condition: {
+                type: 'value',
+                value: false,
+              },
+            },
+            sometimesVisibleElement: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {},
+              tag: 'div',
+              children: [],
+              style: {},
+              condition: {
+                type: 'path',
+                path: ['Variables', 'maybe'],
+              },
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+
+    const fixedFiles = fixProject({
+      files,
+      rule: noStaticNodeCondition,
+      fixType: 'remove-node',
+    })
+
+    expect(fixedFiles).toMatchInlineSnapshot(`
+      {
+        "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": {},
+          },
+        },
+      }
+    `)
+  })
+})

package/src/rules/logic/noStaticNodeCondition.ts

@@ -0,0 +1,43 @@
+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: nodePath, value, nodeType }) => {
+    if (nodeType !== 'component-node' || !value.condition) {
+      return
+    }
+
+    const { isStatic, result } = contextlessEvaluateFormula(value.condition)
+    if (isStatic) {
+      const conditionPath = [...nodePath, 'condition']
+      // - 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(
+        conditionPath,
+        {
+          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/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)
     }