@nordcraft/search 1.0.53 → 1.0.55

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

@@ -0,0 +1,99 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownFormulaRule } from './unknownFormulaRule'
+
+describe('unknownFormula', () => {
+  test('should detect apply formulas with unknown function', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'apply',
+                        name: 'unknown',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown formula')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not detect apply formulas with known function', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'apply',
+                        name: 'known',
+                        arguments: [],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {
+                known: {
+                  name: 'known',
+                  arguments: [],
+                  formula: {
+                    type: 'value',
+                    value: null,
+                  },
+                  '@nordcraft/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownFormulaRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

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

@@ -0,0 +1,21 @@
+import { isFormulaApplyOperation } from '@nordcraft/core/dist/formula/formula'
+import type { Rule } from '../../../types'
+
+export const unknownFormulaRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'formula' || !isFormulaApplyOperation(value)) {
+      return
+    }
+
+    const [, componentName] = path
+    const component = files.components[componentName]
+    if (!component?.formulas?.[value.name]) {
+      report(path, { name: value.name })
+    }
+  },
+}

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

@@ -0,0 +1,112 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownProjectFormulaInputRule } from './unknownProjectFormulaInputRule'
+
+describe('unknownProjectFormulaInput', () => {
+  test('should detect invalid project formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'Unknown'] },
+                  },
+                  {
+                    name: '1',
+                    formula: { type: 'path', path: ['Args', null as any] },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [{ name: 'Input', formula: valueFormula(null) }],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown project formula input')
+    expect(problems[0].details).toEqual({ name: 'Unknown' })
+    expect(problems[1].code).toBe('unknown project formula input')
+    expect(problems[1].details).toEqual({ name: null })
+  })
+  test('should not detect valid project formula input references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'Input'] },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [{ name: 'Input', formula: valueFormula(null) }],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+  test('should not detect @toddle.parent/item path formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'Test',
+              formula: {
+                type: 'function',
+                name: '@toddle/concatenate',
+                arguments: [
+                  {
+                    name: '0',
+                    formula: { type: 'path', path: ['Args', 'item'] },
+                  },
+                  {
+                    name: '0',
+                    formula: {
+                      type: 'path',
+                      path: ['Args', '@toddle.parent', 'test'],
+                    },
+                  },
+                ],
+                variableArguments: true,
+                display_name: 'Concatenate',
+              },
+              arguments: [],
+            },
+          },
+          components: {},
+        },
+        rules: [unknownProjectFormulaInputRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

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

@@ -0,0 +1,32 @@
+import type { ComponentFormula } from '@nordcraft/core/dist/component/component.types'
+import { get } from '@nordcraft/core/dist/utils/collections'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+
+export const unknownProjectFormulaInputRule: Rule<{
+  name?: string | null
+}> = {
+  code: 'unknown project formula input',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path?.[0] !== 'Args' ||
+      ['@toddle.parent', 'item', 'index'].includes(value.path[1]) ||
+      value.path.length < 2 ||
+      path[0] !== 'formulas' ||
+      path.length < 2
+    ) {
+      return
+    }
+    const [formulas, formulaName] = path as string[]
+    const formula: ComponentFormula = get(files, [formulas, formulaName])
+    const args = formula.arguments ?? []
+    const argName = value.path[1]
+    if (!isDefined(argName) || !args.some((arg) => arg.name === argName)) {
+      report(path, { name: argName })
+    }
+  },
+}

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

@@ -0,0 +1,126 @@
+import {
+  functionFormula,
+  valueFormula,
+} from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownProjectFormulaRule } from './unknownProjectFormulaRule'
+
+describe('unknownProjectFormulaRule', () => {
+  test('should find unknown project formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: functionFormula('missing-formula'),
+                    'other-test': functionFormula('package-formula', {
+                      package: 'my-package',
+                    }),
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown project formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'attrs',
+      'test',
+    ])
+    expect(problems[1].code).toBe('unknown project formula')
+    expect(problems[1].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      'root',
+      'attrs',
+      'other-test',
+    ])
+  })
+  test('should not report known formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'known-formula': {
+              formula: valueFormula(true),
+              name: 'known-formula',
+              arguments: [],
+            },
+          },
+          packages: {
+            'my-package': {
+              components: {},
+              actions: {},
+              formulas: {
+                'package-formula': {
+                  formula: valueFormula(true),
+                  name: 'package-formula',
+                  arguments: [],
+                },
+              },
+              manifest: {
+                name: 'my-package',
+                commit: '123',
+              },
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {
+                    test: functionFormula('known-formula'),
+                    'other-test': functionFormula('package-formula', {
+                      package: 'my-package',
+                    }),
+                    time: functionFormula('@toddle/now'),
+                  },
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/issues/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/issues/formulas/unknownRepeatIndexFormulaRule.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test'
+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/issues/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)
+    }
+  },
+}