@nordcraft/search 1.0.61 → 1.0.63

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

@@ -65,6 +65,134 @@ describe('unknownRepeatIndexFormulaRule', () => {
       'value',
     ])
   })
+  test('should find unknown repeat index formulas outside of nodes', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                myWorkflow: {
+                  name: 'myWorkflow',
+                  parameters: [],
+                  actions: [
+                    {
+                      name: '@toddle/logToConsole',
+                      group: 'debugging',
+                      label: 'Log to console',
+                      arguments: [
+                        {
+                          name: 'Label',
+                          formula: { type: 'value', value: '' },
+                          description: 'A label for the message.',
+                        },
+                        {
+                          name: 'Data',
+                          type: { type: 'Any' },
+                          formula: {
+                            type: 'path',
+                            path: ['ListItem', 'Index'],
+                          },
+                          description:
+                            'The data you want to log to the console.',
+                        },
+                      ],
+                      description: 'Log a message to the browser console.',
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownRepeatIndexFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat index formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'workflows',
+      'myWorkflow',
+      'actions',
+      0,
+      'arguments',
+      '1',
+      'formula',
+    ])
+  })
+  test('should find unknown repeat index outside of a component', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'myFormula',
+              formula: {
+                name: '@toddle/concatenate',
+                type: 'function',
+                arguments: [
+                  {
+                    name: '0',
+                    type: {
+                      type: 'Array \\| String \\| Object',
+                    },
+                    formula: {
+                      path: ['Args', 'First'],
+                      type: 'path',
+                    },
+                  },
+                  {
+                    name: '0',
+                    type: {
+                      type: 'Array \\| String \\| Object',
+                    },
+                    formula: {
+                      type: 'path',
+                      path: ['ListItem', 'Index'],
+                    },
+                  },
+                ],
+                display_name: 'Concatenate',
+                variableArguments: true,
+              },
+              version: 2,
+              arguments: [
+                {
+                  name: 'First',
+                  formula: null,
+                  testValue: 'sdfsdf',
+                },
+              ],
+              description: 'sdfsdfsdf',
+            },
+          },
+          components: {},
+        },
+        rules: [unknownRepeatIndexFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat index formula')
+    expect(problems[0].path).toEqual([
+      'formulas',
+      'myFormula',
+      'formula',
+      'arguments',
+      1,
+      'formula',
+    ])
+  })
   test('should ignore known repeat index formulas', () => {
     const problems = Array.from(
       searchProject({

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

@@ -10,13 +10,14 @@ export const unknownRepeatIndexFormulaRule: Rule = {
       nodeType !== 'formula' ||
       value.type !== 'path' ||
       value.path?.[0] !== 'ListItem' ||
-      value.path?.[1] !== 'Index' ||
-      path.length < 3 ||
-      path[0] !== 'components' ||
-      path[2] !== 'nodes'
+      value.path?.[1] !== 'Index'
     ) {
       return
     }
+    if (path[0] !== 'components' || path[2] !== 'nodes') {
+      // Any use outside of a component node is invalid
+      return report(path)
+    }
     const [_components, componentName, _nodes, nodeId] = path as string[]
     const component = files.components[componentName]
     if (!component) {

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

@@ -65,6 +65,149 @@ describe('unknownRepeatItemFormulaRule', () => {
       'value',
     ])
   })
+  test('should find unknown repeat item outside of nodes', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'load',
+                actions: [
+                  {
+                    name: '@toddle/logToConsole',
+                    group: 'debugging',
+                    label: 'Log to console',
+                    arguments: [
+                      {
+                        name: 'Label',
+                        formula: { type: 'value', value: '' },
+                        description: 'A label for the message.',
+                      },
+                      {
+                        name: 'Data',
+                        type: { type: 'Any' },
+                        formula: {
+                          type: 'function',
+                          name: '@toddle/concatenate',
+                          arguments: [
+                            {
+                              name: '0',
+                              formula: { type: 'value', value: 'Hello' },
+                              type: { type: 'Array \\| String \\| Object' },
+                            },
+                            {
+                              name: '0',
+                              formula: {
+                                type: 'path',
+                                path: ['ListItem', 'Item'],
+                              },
+                              type: { type: 'Array \\| String \\| Object' },
+                            },
+                          ],
+                          variableArguments: true,
+                          display_name: 'Concatenate',
+                        },
+                        description: 'The data you want to log to the console.',
+                      },
+                    ],
+                    description: 'Log a message to the browser console.',
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [unknownRepeatItemFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat item formula')
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'onLoad',
+      'actions',
+      '0',
+      'arguments',
+      '1',
+      'formula',
+      'arguments',
+      1,
+      'formula',
+    ])
+  })
+  test('should find unknown repeat item outside of a component', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            myFormula: {
+              name: 'myFormula',
+              formula: {
+                name: '@toddle/concatenate',
+                type: 'function',
+                arguments: [
+                  {
+                    name: '0',
+                    type: {
+                      type: 'Array \\| String \\| Object',
+                    },
+                    formula: {
+                      path: ['Args', 'First'],
+                      type: 'path',
+                    },
+                  },
+                  {
+                    name: '0',
+                    type: {
+                      type: 'Array \\| String \\| Object',
+                    },
+                    formula: {
+                      type: 'path',
+                      path: ['ListItem', 'Item'],
+                    },
+                  },
+                ],
+                display_name: 'Concatenate',
+                variableArguments: true,
+              },
+              version: 2,
+              arguments: [
+                {
+                  name: 'First',
+                  formula: null,
+                  testValue: 'sdfsdf',
+                },
+              ],
+              description: 'sdfsdfsdf',
+            },
+          },
+          components: {},
+        },
+        rules: [unknownRepeatItemFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown repeat item formula')
+    expect(problems[0].path).toEqual([
+      'formulas',
+      'myFormula',
+      'formula',
+      'arguments',
+      1,
+      'formula',
+    ])
+  })
   test('should ignore known repeat item formulas', () => {
     const problems = Array.from(
       searchProject({

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

@@ -10,13 +10,15 @@ export const unknownRepeatItemFormulaRule: Rule = {
       nodeType !== 'formula' ||
       value.type !== 'path' ||
       value.path?.[0] !== 'ListItem' ||
-      value.path?.[1] !== 'Item' ||
-      path.length < 3 ||
-      path[0] !== 'components' ||
-      path[2] !== 'nodes'
+      value.path?.[1] !== 'Item'
     ) {
       return
     }
+    if (path[0] !== 'components' || path[2] !== 'nodes') {
+      // Any use outside of a component node is invalid
+      // For instance in global formulas or in workflows
+      return report(path)
+    }
     const [_components, componentName, _nodes, nodeId] = path as string[]
     const component = files.components[componentName]
     if (!component) {

package/src/rules/issues/style/unknownClassnameRule.ts

@@ -12,7 +12,7 @@ export const unknownClassnameRule: Rule<{
       nodeType !== 'style-variant' ||
       typeof value.variant.className !== 'string' ||
       value.element.type !== 'element' ||
-      isDefined(value.element.classes[value.variant.className])
+      isDefined(value.element.classes?.[value.variant.className])
     ) {
       return
     }

package/src/types.d.ts

@@ -41,7 +41,9 @@ import type { NoReferenceVariableRuleFix } from './rules/issues/variables/noRefe
 import type { NoPostNavigateActionRuleFix } from './rules/issues/workflows/noPostNavigateAction'
 
 type Code =
+  | 'duplicate action argument name'
   | 'duplicate event trigger'
+  | 'duplicate formula argument name'
   | 'duplicate url parameter'
   | 'duplicate workflow parameter'
   | 'duplicate route'