@nordcraft/search 1.0.45 → 1.0.46

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)
     }

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/types.d.ts

@@ -30,6 +30,7 @@ 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'
 
@@ -59,6 +60,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'
@@ -343,6 +345,7 @@ type FixType =
   | 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,
+    })
+  })
+})

package/src/util/contextlessEvaluateFormula.ts

@@ -0,0 +1,110 @@
+import { type Formula } from '@nordcraft/core/dist/formula/formula'
+
+/**
+ * Static evaluation of a formula.
+ *
+ * Can be used by issues to determine if a formula or sub-formula can be reduced to a static value.
+ * When sophisticated enough, it can be used during compile-time to reduce all static subgraphs of a formula to static values, greatly reducing payload and improving runtime performance.
+ *
+ * @returns {
+ *  isStatic: boolean; // Whether the formula is static (i.e., does not depend on any variables, context AND only use pure formulas (no Random, Date, etc.))
+ *  result: unknown; // The evaluated value of the formula
+ * }
+ *
+ * TODO: Make this function more capable of evaluating pure core formulas.
+ * TODO: Memoize the results (using path or a fast hash) to avoid re-evaluating any similar sub-graphs multiple times.
+ * TODO: Add a complex test-suite to ensure it works and develops as expected.
+ */
+export const contextlessEvaluateFormula = (
+  formula: Formula,
+): {
+  isStatic: boolean
+  result: unknown
+} => {
+  // Very basic implementation, just to get started.
+  switch (formula.type) {
+    case 'value': {
+      return {
+        isStatic: true,
+        result: formula.value,
+      }
+    }
+
+    case 'array': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      return {
+        isStatic: results.every((res) => res.isStatic),
+        result: results.map((res) => res.result),
+      }
+    }
+
+    case 'record': {
+      const entries = Object.entries(formula.entries).map(
+        ([key, arg]) => [key, contextlessEvaluateFormula(arg.formula)] as const,
+      )
+
+      const results = entries.map(([, res]) => res)
+
+      return {
+        isStatic: results.every((res) => res.isStatic),
+        result: Object.fromEntries(
+          entries.map(([key, res]) => [key, res.result]),
+        ),
+      }
+    }
+
+    // Static if:
+    // - ALL conditions are static AND truthy
+    // - ANY condition is static and falsy
+    // - EMPTY argument list is always true
+    case 'and': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      const alwaysTrue =
+        results.length === 0 ||
+        results.every((res) => res.isStatic && Boolean(res.result) === true)
+      const alwaysFalsy = results.some(
+        (res) => res.isStatic && Boolean(res.result) === false,
+      )
+
+      return {
+        isStatic: alwaysTrue || alwaysFalsy,
+        result: alwaysTrue ? true : alwaysFalsy ? false : undefined,
+      }
+    }
+
+    // Static if:
+    // - ANY condition is static AND truthy
+    // - ALL conditions are static AND falsy
+    // - EMPTY argument list is always false
+    case 'or': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      const alwaysFalsy =
+        results.length === 0 ||
+        results.every((res) => res.isStatic && Boolean(res.result) === false)
+      const alwaysTrue = results.some(
+        (res) => res.isStatic && Boolean(res.result) === true,
+      )
+
+      return {
+        isStatic: alwaysTrue || alwaysFalsy,
+        result: alwaysFalsy ? false : alwaysTrue ? true : undefined,
+      }
+    }
+
+    default:
+      // For now, we assume that any other formula is not static.
+      return {
+        isStatic: false,
+        result: undefined,
+      }
+  }
+}

package/src/util/removeUnused.fix.ts

@@ -1,5 +1,33 @@
-import { omit } from '@nordcraft/core/dist/utils/collections'
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import { get, omit, set } from '@nordcraft/core/dist/utils/collections'
 import type { FixFunction, NodeType } from '../types'
 
 export const removeFromPathFix: FixFunction<NodeType> = ({ path, files }) =>
   omit(files, path)
+
+/**
+ * Same as removeFromPathFix, but also removes the node from its parent's children.
+ */
+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
+  >
+  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],
+      )
+    }
+  }
+
+  return set(filesWithoutNode, componentNodesPath, nodes)
+}