@nordcraft/search 1.0.0

package/src/problems.worker.ts

@@ -0,0 +1,225 @@
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
+import { createActionNameRule } from './rules/actions/createActionNameRule'
+import { legacyActionRule } from './rules/actions/legacyActionRule'
+import { noReferenceProjectActionRule } from './rules/actions/noReferenceProjectActionRule'
+import { unknownProjectActionRule } from './rules/actions/unknownProjectActionRule'
+import { legacyApiRule } from './rules/apis/legacyApiRule'
+import { noReferenceApiRule } from './rules/apis/noReferenceApiRule'
+import { unknownApiInputRule } from './rules/apis/unknownApiInputRule'
+import { unknownApiRule } from './rules/apis/unknownApiRule'
+import { noReferenceAttributeRule } from './rules/attributes/noReferenceAttributeRule'
+import { unknownAttributeRule } from './rules/attributes/unknownAttributeRule'
+import { noReferenceComponentRule } from './rules/components/noReferenceComponentRule'
+import { unknownComponentRule } from './rules/components/unknownComponentRule'
+import { noContextConsumersRule } from './rules/context/noContextConsumersRule'
+import { unknownContextFormulaRule } from './rules/context/unknownContextFormulaRule'
+import { unknownContextProviderFormulaRule } from './rules/context/unknownContextProviderFormulaRule'
+import { unknownContextProviderRule } from './rules/context/unknownContextProviderRule'
+import { createRequiredDirectChildRule } from './rules/dom/createRequiredDirectChildRule'
+import { createRequiredDirectParentRule } from './rules/dom/createRequiredDirectParentRule'
+import { createRequiredElementAttributeRule } from './rules/dom/createRequiredElementAttributeRule'
+import { createRequiredMetaTagRule } from './rules/dom/createRequiredMetaTagRule'
+import { imageWithoutDimensionRule } from './rules/dom/imageWithoutDimensionRule'
+import { nonEmptyVoidElementRule } from './rules/dom/nonEmptyVoidElementRule'
+import { duplicateRouteRule } from './rules/duplicateRouteRule'
+import { duplicateEventTriggerRule } from './rules/events/duplicateEventTriggerRule'
+import { noReferenceEventRule } from './rules/events/noReferenceEventRule'
+import { unknownEventRule } from './rules/events/unknownEventRule'
+import { unknownTriggerEventRule } from './rules/events/unknownTriggerEventRule'
+import { legacyFormulaRule } from './rules/formulas/legacyFormulaRule'
+import { noReferenceComponentFormulaRule } from './rules/formulas/noReferenceComponentFormulaRule'
+import { noReferenceProjectFormulaRule } from './rules/formulas/noReferenceProjectFormulaRule'
+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 { noUnnecessaryConditionFalsy } from './rules/logic/noUnnecessaryConditionFalsy'
+import { noUnnecessaryConditionTruthy } from './rules/logic/noUnnecessaryConditionTruthy'
+import { requireExtensionRule } from './rules/requireExtensionRule'
+import { unknownClassnameRule } from './rules/slots/unknownClassnameRule'
+import { unknownComponentSlotRule } from './rules/slots/unknownComponentSlotRule'
+import { unknownCookieRule } from './rules/unknownCookieRule'
+import { duplicateUrlParameterRule } from './rules/urlParameters/duplicateUrlParameterRule'
+import { unknownSetUrlParameterRule } from './rules/urlParameters/unknownSetUrlParameterRule'
+import { unknownUrlParameterRule } from './rules/urlParameters/unknownUrlParameterRule'
+import { noReferenceVariableRule } from './rules/variables/noReferenceVariableRule'
+import { unknownVariableRule } from './rules/variables/unknownVariableRule'
+import { unknownVariableSetterRule } from './rules/variables/unknownVariableSetterRule'
+import { duplicateWorkflowParameterRule } from './rules/workflows/duplicateWorkflowParameterRule'
+import { noReferenceComponentWorkflowRule } from './rules/workflows/noReferenceComponentWorkflowRule'
+import { unknownContextProviderWorkflowRule } from './rules/workflows/unknownContextProviderWorkflowRule'
+import { unknownContextWorkflowRule } from './rules/workflows/unknownContextWorkflowRule'
+import { unknownTriggerWorkflowParameterRule } from './rules/workflows/unknownTriggerWorkflowParameterRule'
+import { unknownTriggerWorkflowRule } from './rules/workflows/unknownTriggerWorkflowRule'
+import { unknownWorkflowParameterRule } from './rules/workflows/unknownWorkflowParameterRule'
+import { searchProject } from './searchProject'
+import type { ApplicationState, Category, Code, Level, Result } from './types'
+
+export type Options = {
+  /**
+   * Useful for running search on a subset or a single file.
+   */
+  pathsToVisit?: string[][]
+  /**
+   * Search only rules with these specific categories. If empty, all categories are shown.
+   */
+  categories?: Category[]
+  /**
+   * Search only rules with the specific levels. If empty, all levels are shown.
+   */
+  levels?: Level[]
+  /**
+   * The number of reports to send per message.
+   * @default 1
+   */
+  batchSize?: number | 'all' | 'per-file'
+  /**
+   * Dynamic data that is used by some rules.
+   */
+  state?: ApplicationState
+
+  rulesToExclude?: Code[]
+}
+
+const RULES = [
+  createActionNameRule({ name: '@toddle/logToConsole', code: 'no-console' }),
+  createRequiredElementAttributeRule('a', 'href'),
+  createRequiredElementAttributeRule('img', 'alt'),
+  createRequiredElementAttributeRule('img', 'src'),
+  createRequiredMetaTagRule('description'),
+  createRequiredMetaTagRule('title'),
+  createRequiredDirectChildRule(['ul', 'ol'], ['li', 'script', 'template']),
+  createRequiredDirectParentRule(['ul', 'ol'], ['li']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/table#technical_summary
+  createRequiredDirectChildRule(
+    ['table'],
+    ['caption', 'colgroup', 'tbody', 'thead', 'tfoot', 'tr'],
+  ),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tbody#technical_summary
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/thead#technical_summary
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tfoot#technical_summary
+  createRequiredDirectParentRule(['table'], ['tbody', 'thead', 'tfoot']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/tr#technical_summary
+  createRequiredDirectChildRule(['tr'], ['th', 'td', 'script', 'template']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/th#technical_summary
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/td#technical_summary
+  createRequiredDirectParentRule(['tr'], ['th', 'td']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/select#technical_summary
+  createRequiredDirectChildRule(['select'], ['option', 'optgroup', 'hr']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/optgroup#technical_summary
+  createRequiredDirectChildRule(['optgroup'], ['option']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/legend#technical_summary
+  createRequiredDirectParentRule(['fieldset'], ['legend']),
+  // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dl#technical_summary
+  createRequiredDirectChildRule(
+    ['dl'],
+    ['dd', 'dt', 'div', 'script', 'template'],
+  ),
+  duplicateEventTriggerRule,
+  duplicateRouteRule,
+  duplicateUrlParameterRule,
+  duplicateWorkflowParameterRule,
+  imageWithoutDimensionRule,
+  legacyActionRule,
+  legacyApiRule,
+  legacyFormulaRule,
+  noContextConsumersRule,
+  nonEmptyVoidElementRule,
+  noReferenceApiRule,
+  noReferenceAttributeRule,
+  noReferenceComponentFormulaRule,
+  noReferenceComponentRule,
+  noReferenceComponentWorkflowRule,
+  noReferenceEventRule,
+  noReferenceProjectActionRule,
+  noReferenceProjectFormulaRule,
+  noReferenceVariableRule,
+  noUnnecessaryConditionFalsy,
+  noUnnecessaryConditionTruthy,
+  requireExtensionRule,
+  unknownApiRule,
+  unknownApiInputRule,
+  unknownAttributeRule,
+  unknownClassnameRule,
+  // unknownComponentFormulaInputRule,
+  unknownComponentRule,
+  unknownComponentSlotRule,
+  unknownContextFormulaRule,
+  unknownContextProviderFormulaRule,
+  unknownContextProviderRule,
+  unknownContextProviderWorkflowRule,
+  unknownContextWorkflowRule,
+  unknownCookieRule,
+  unknownEventRule,
+  unknownFormulaRule,
+  unknownProjectActionRule,
+  // unknownProjectFormulaInputRule,
+  unknownProjectFormulaRule,
+  unknownRepeatIndexFormulaRule,
+  unknownRepeatItemFormulaRule,
+  unknownSetUrlParameterRule,
+  unknownTriggerEventRule,
+  unknownTriggerWorkflowParameterRule,
+  unknownTriggerWorkflowRule,
+  unknownUrlParameterRule,
+  unknownVariableRule,
+  unknownVariableSetterRule,
+  unknownWorkflowParameterRule,
+]
+
+/**
+ * This function is a web worker that checks for problems in the files.
+ */
+onmessage = (
+  event: MessageEvent<{ files: ProjectFiles; options?: Options }>,
+) => {
+  const { files, options = {} } = event.data
+  const rules = RULES.filter(
+    (rule) =>
+      (!options.categories || options.categories.includes(rule.category)) &&
+      (!options.levels || options.levels.includes(rule.level)) &&
+      !options.rulesToExclude?.includes(rule.code),
+  )
+
+  let batch: Result[] = []
+  let fileType: string | number | undefined
+  let fileName: string | number | undefined
+  for (const problem of searchProject({
+    files,
+    rules,
+    pathsToVisit: options.pathsToVisit,
+    state: options.state,
+  })) {
+    switch (options.batchSize) {
+      case 'all': {
+        batch.push(problem)
+        break
+      }
+      case 'per-file': {
+        if (fileType !== problem.path[0] || fileName !== problem.path[1]) {
+          if (batch.length > 0) {
+            postMessage(batch)
+          }
+          batch = []
+          fileType = problem.path[0]
+          fileName = problem.path[1]
+        }
+
+        batch.push(problem)
+        break
+      }
+
+      default: {
+        batch.push(problem)
+        if (batch.length >= (options.batchSize ?? 1)) {
+          postMessage(batch)
+          batch = []
+        }
+        break
+      }
+    }
+  }
+
+  // Send the remaining results
+  postMessage(batch)
+}

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

@@ -0,0 +1,100 @@
+import { searchProject } from '../../searchProject'
+import { createActionNameRule } from './createActionNameRule'
+
+describe('createActionNameRule', () => {
+  test('should report use of console log', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'Switch',
+                          cases: [
+                            {
+                              condition: {
+                                type: 'function',
+                                name: '@toddle/notEqual',
+                                arguments: [
+                                  {
+                                    name: 'First',
+                                    formula: {
+                                      type: 'value',
+                                      value: false,
+                                    },
+                                  },
+                                  {
+                                    name: 'Second',
+                                    formula: {
+                                      type: 'value',
+                                      value: true,
+                                    },
+                                  },
+                                ],
+                              },
+                              actions: [
+                                {
+                                  name: '@toddle/logToConsole',
+                                  arguments: [
+                                    {
+                                      name: 'Label',
+                                      formula: {
+                                        type: 'value',
+                                        value: 'my',
+                                      },
+                                    },
+                                    {
+                                      name: 'Data',
+                                      formula: {
+                                        type: 'value',
+                                        value: 'message',
+                                      },
+                                    },
+                                  ],
+                                },
+                              ],
+                            },
+                          ],
+                          default: {
+                            actions: [],
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [
+          createActionNameRule({
+            name: '@toddle/logToConsole',
+            code: 'no-console',
+          }),
+        ],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-console')
+    expect(problems[0].level).toEqual('info')
+  })
+})

package/src/rules/actions/createActionNameRule.ts

@@ -0,0 +1,38 @@
+import type { Category, Code, Level, Rule } from '../../types'
+
+/**
+ * Generic rule factory for creating a rule that checks for a specific action name.
+ * Useful for extending other rules, such as for deprecated actions.
+ * @example
+ * myRule = () => createActionNameRule('myAction', myRule.code)
+ */
+export function createActionNameRule({
+  name,
+  code,
+  category = 'Other',
+  level = 'info',
+}: {
+  name: string
+  code: Code
+  category?: Category
+  level?: Level
+}): Rule<{
+  name: string
+}> {
+  return {
+    code,
+    category,
+    level,
+    visit: (report, { path, value, nodeType }) => {
+      if (
+        nodeType !== 'action-model' ||
+        (value.type !== undefined && value.type !== 'Custom') ||
+        value.name !== name
+      ) {
+        return
+      }
+
+      report(path, { name: value.name })
+    },
+  }
+}

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

@@ -0,0 +1,91 @@
+import { searchProject } from '../../searchProject'
+import { legacyActionRule } from './legacyActionRule'
+
+describe('legacyAction', () => {
+  test('should detect legacy actions used in components', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'Load',
+                actions: [
+                  {
+                    name: 'If',
+                    events: {
+                      true: {
+                        actions: [],
+                      },
+                      false: {
+                        actions: [],
+                      },
+                    },
+                    arguments: [
+                      {
+                        name: 'Condition',
+                        formula: {
+                          type: 'value',
+                          value: true,
+                        },
+                      },
+                    ],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [legacyActionRule],
+      }),
+    )
+    expect(problems).toHaveLength(1)
+    expect(problems[0].path).toEqual([
+      'components',
+      'apiComponent',
+      'onLoad',
+      'actions',
+      '0',
+    ])
+  })
+  test('should not detect non-legacy actions used in components', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            apiComponent: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              onLoad: {
+                trigger: 'Load',
+                actions: [
+                  {
+                    type: 'Fetch',
+                    api: 'my-api',
+                    inputs: {},
+                    onSuccess: { actions: [] },
+                    onError: { actions: [] },
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [legacyActionRule],
+      }),
+    )
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/actions/legacyActionRule.ts

@@ -0,0 +1,26 @@
+import type { Rule } from '../../types'
+import { isLegacyAction } from '../../util/helpers'
+
+export const legacyActionRule: Rule<{
+  name: string
+}> = {
+  code: 'legacy action',
+  level: 'warning',
+  category: 'Deprecation',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'action-model') {
+      return
+    }
+
+    if (isLegacyAction(value)) {
+      let details: { name: string } | undefined
+      if ('name' in value) {
+        details = {
+          name: value.name,
+        }
+      }
+
+      report(path, details)
+    }
+  },
+}

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

@@ -0,0 +1,130 @@
+import { searchProject } from '../../searchProject'
+import { noReferenceProjectActionRule } from './noReferenceProjectActionRule'
+
+describe('noReferenceProjectAction', () => {
+  test('should detect unused global actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          actions: {
+            'my-action': {
+              name: 'my-action',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectActionRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project action')
+    expect(problems[0].path).toEqual(['actions', 'my-action'])
+  })
+
+  test('should not detect used global actions', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          actions: {
+            'my-action': {
+              name: 'my-action',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+            'my-action2': {
+              name: 'my-action2',
+              arguments: [],
+              handler: '() => console.log("test")',
+              variableArguments: false,
+            },
+          },
+          components: {
+            test: {
+              name: 'test',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              workflows: {
+                test: {
+                  name: 'test',
+                  parameters: [],
+                  actions: [
+                    {
+                      name: 'my-action2',
+                      arguments: [],
+                    },
+                  ],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              onLoad: {
+                trigger: 'onLoad',
+                actions: [
+                  {
+                    type: 'Custom',
+                    name: 'my-action',
+                    arguments: [],
+                  },
+                ],
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectActionRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+
+  describe('noReferenceProjectAction', () => {
+    test('should not detect exported unused global actions', () => {
+      const problems = Array.from(
+        searchProject({
+          files: {
+            actions: {
+              'my-action': {
+                name: 'my-action',
+                arguments: [],
+                handler: '() => console.log("test")',
+                variableArguments: false,
+                exported: true,
+              },
+            },
+            components: {
+              test: {
+                name: 'test',
+                nodes: {},
+                formulas: {},
+                apis: {},
+                attributes: {},
+                variables: {},
+              },
+            },
+          },
+          rules: [noReferenceProjectActionRule],
+        }),
+      )
+
+      expect(problems).toHaveLength(0)
+    })
+  })
+})

package/src/rules/actions/noReferenceProjectActionRule.ts

@@ -0,0 +1,47 @@
+import type { CustomActionModel } from '@nordcraft/core/dist/component/component.types'
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { Rule } from '../../types'
+
+export const noReferenceProjectActionRule: Rule<void> = {
+  code: 'no-reference project action',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, { path, files, value, nodeType, memo }) => {
+    if (nodeType !== 'project-action' || value.exported === true) {
+      return
+    }
+
+    const projectActionReferences = memo('projectActionReferences', () => {
+      const usedActions = new Set<string>()
+      for (const component of Object.values(files.components)) {
+        const c = new ToddleComponent({
+          // Enforce that the component is not undefined since we're iterating
+          component: component!,
+          getComponent: (name, packageName) =>
+            packageName
+              ? files.packages?.[packageName]?.components[name]
+              : files.components[name],
+          packageName: undefined,
+          globalFormulas: {
+            formulas: files.formulas,
+            packages: files.packages,
+          },
+        })
+        for (const [, action] of c.actionModelsInComponent()) {
+          if (
+            action.type === 'Custom' ||
+            action.type === ('function' as any) ||
+            action.type === undefined
+          ) {
+            usedActions.add((action as CustomActionModel).name)
+          }
+        }
+      }
+      return usedActions
+    })
+
+    if (!projectActionReferences.has(value.name)) {
+      report(path)
+    }
+  },
+}