@nordcraft/search 1.0.0

package/src/rules/formulas/unknownProjectFormulaRule.ts

@@ -0,0 +1,23 @@
+import type { Rule } from '../../types'
+
+export const unknownProjectFormulaRule: Rule<{ name: string }> = {
+  code: 'unknown project formula',
+  level: 'warning',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'function' ||
+      (value.name ?? '').startsWith('@toddle/')
+    ) {
+      return
+    }
+    const formula = (
+      value.package ? files.packages?.[value.package]?.formulas : files.formulas
+    )?.[value.name]
+    if (formula) {
+      return
+    }
+    report(path, { name: value.name })
+  },
+}

package/src/rules/formulas/unknownRepeatIndexFormulaRule.test.ts

@@ -0,0 +1,138 @@
+import { searchProject } from '../../searchProject'
+import { unknownRepeatIndexFormulaRule } from './unknownRepeatIndexFormulaRule'
+
+describe('unknownRepeatIndexFormulaRule', () => {
+  test('should find unknown repeat index formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                '84CPDAaFJdwh8Vaimehky': {
+                  type: 'text',
+                  value: {
+                    type: 'path',
+                    path: ['ListItem', 'Index'],
+                  },
+                },
+                '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: [unknownRepeatIndexFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat index formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      '84CPDAaFJdwh8Vaimehky',
+      'value',
+    ])
+  })
+  test('should ignore known repeat index formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                '84CPDAaFJdwh8Vaimehky': {
+                  type: 'text',
+                  value: {
+                    type: 'path',
+                    path: ['ListItem', 'Index'],
+                  },
+                },
+                '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: [unknownRepeatIndexFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/formulas/unknownRepeatIndexFormulaRule.ts

@@ -0,0 +1,46 @@
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import type { Rule } from '../../types'
+
+export const unknownRepeatIndexFormulaRule: Rule = {
+  code: 'unknown repeat index 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] !== 'Index' ||
+      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/formulas/unknownRepeatItemFormulaRule.test.ts

@@ -0,0 +1,138 @@
+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/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/logic/noUnnecessaryConditionFalsy.test.ts

@@ -0,0 +1,101 @@
+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)
+  })
+})

package/src/rules/logic/noUnnecessaryConditionFalsy.ts

@@ -0,0 +1,21 @@
+import type { Rule } from '../../types'
+
+export const noUnnecessaryConditionFalsy: Rule = {
+  code: 'no-unnecessary-condition-falsy',
+  level: 'info',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'formula' || value.type !== 'and') {
+      return
+    }
+
+    if (
+      value.arguments.some(
+        (arg) =>
+          arg.formula.type === 'value' && Boolean(arg.formula.value) === false,
+      )
+    ) {
+      report(path)
+    }
+  },
+}

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

@@ -0,0 +1,125 @@
+import { searchProject } from '../../searchProject'
+import { noUnnecessaryConditionTruthy } from './noUnnecessaryConditionTruthy'
+
+describe('noUnnecessaryConditionTruthy', () => {
+  test('should report unnecessary 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: [],
+                          },
+                        },
+                        {
+                          formula: {
+                            type: 'value',
+                            value: true,
+                          },
+                        },
+                      ],
+                    },
+                    test2: {
+                      type: 'or',
+                      arguments: [
+                        {
+                          formula: {
+                            type: 'object',
+                            arguments: [],
+                          },
+                        },
+                      ],
+                    },
+                    test3: {
+                      type: 'or',
+                      arguments: [
+                        {
+                          formula: {
+                            type: 'array',
+                            arguments: [],
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noUnnecessaryConditionTruthy],
+      }),
+    )
+
+    expect(problems).toHaveLength(3)
+    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', () => {
+    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: [noUnnecessaryConditionTruthy],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/logic/noUnnecessaryConditionTruthy.ts

@@ -0,0 +1,25 @@
+import type { Rule } from '../../types'
+
+export const noUnnecessaryConditionTruthy: Rule = {
+  code: 'no-unnecessary-condition-truthy',
+  level: 'info',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'formula' || value.type !== 'or') {
+      return
+    }
+
+    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',
+      )
+    ) {
+      report(path)
+    }
+  },
+}