@nordcraft/search 1.0.0

package/src/rules/context/noContextConsumersRule.ts

@@ -0,0 +1,39 @@
+import type { Rule } from '../../types'
+
+/**
+ * Rule for checking if a component exposes formulas or workflows
+ * in context but has no slots or components that could consume them
+ */
+export const noContextConsumersRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'no context consumers',
+  level: 'warning',
+  category: 'Quality',
+  visit: (report, { path, value, nodeType }) => {
+    if (nodeType !== 'component') {
+      return
+    }
+    const exposesFormulas = Object.values(value.formulas ?? {}).some(
+      (f) => f.exposeInContext,
+    )
+    const exposesWorkflows = Object.values(value.workflows ?? {}).some(
+      (w) => w.exposeInContext,
+    )
+    if (!exposesFormulas && !exposesWorkflows) {
+      return
+    }
+    const hasSlots = Object.values(value.nodes).some((n) => n.type === 'slot')
+    if (hasSlots) {
+      return
+    }
+    const hasComponents = Object.values(value.nodes).some(
+      (n) => n.type === 'component',
+    )
+    if (hasComponents) {
+      return
+    }
+    report(path)
+  },
+}

package/src/rules/context/unknownContextFormulaRule.test.ts

@@ -0,0 +1,93 @@
+import { searchProject } from '../../searchProject'
+import { unknownContextFormulaRule } from './unknownContextFormulaRule'
+
+describe('unknownContextFormulaRule', () => {
+  test('should detect context formulas that are not subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'unknown', 'test'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+                test2: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'unknown'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown context formula')
+    expect(problems[1].code).toBe('unknown context formula')
+  })
+
+  test('should not detect when context formulas are subscribed', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/context/unknownContextFormulaRule.ts

@@ -0,0 +1,30 @@
+import type { Rule } from '../../types'
+
+export const unknownContextFormulaRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'unknown context formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      path[0] !== 'components' ||
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'Contexts'
+    ) {
+      return
+    }
+
+    const contexts = files.components[path[1]]?.contexts ?? {}
+    if (contexts[value.path[1]]?.formulas.includes(value.path[2])) {
+      return
+    }
+
+    report(path, {
+      providerName: value.path[1],
+      formulaName: value.path[2],
+    })
+  },
+}

package/src/rules/context/unknownContextProviderFormulaRule.test.ts

@@ -0,0 +1,174 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { searchProject } from '../../searchProject'
+import { unknownContextProviderFormulaRule } from './unknownContextProviderFormulaRule'
+
+describe('unknownContextFormulaProviderRule', () => {
+  test('should detect invalid context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider formula')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      formulaName: 'test',
+    })
+  })
+  test('should detect non-exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {
+                test: {
+                  name: 'test',
+                  exposeInContext: false,
+                  formula: valueFormula(true),
+                  arguments: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider formula')
+    expect(problems[0].details).toEqual({
+      providerName: 'known',
+      formulaName: 'test',
+    })
+  })
+  test('should not detect exposed context provider formula references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            known: {
+              name: 'known',
+              nodes: {},
+              formulas: {
+                test: {
+                  name: 'test',
+                  exposeInContext: true,
+                  formula: valueFormula(true),
+                  arguments: [],
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {
+                test: {
+                  initialValue: {
+                    type: 'path',
+                    path: ['Contexts', 'known', 'test'],
+                  },
+                  '@toddle/metadata': {
+                    comments: null,
+                  },
+                },
+              },
+              contexts: {
+                known: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'known',
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownContextProviderFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/context/unknownContextProviderFormulaRule.ts

@@ -0,0 +1,35 @@
+import type { Rule } from '../../types'
+
+export const unknownContextProviderFormulaRule: Rule<{
+  providerName: string
+  formulaName: string
+}> = {
+  code: 'unknown context provider formula',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'component-context' ||
+      !value.componentName ||
+      (value.formulas ?? []).length === 0
+    ) {
+      return
+    }
+
+    // Lookup the target component and verify it holds the formula
+    const component = value.package
+      ? files.packages?.[value.package]?.components[value.componentName]
+      : files.components[value.componentName]
+    if (!component) {
+      return
+    }
+    for (const formulaName of value.formulas) {
+      if (component.formulas?.[formulaName]?.exposeInContext !== true) {
+        report(path, {
+          providerName: value.componentName,
+          formulaName,
+        })
+      }
+    }
+  },
+}

package/src/rules/context/unknownContextProviderRule.test.ts

@@ -0,0 +1,79 @@
+import { searchProject } from '../../searchProject'
+import { unknownContextProviderRule } from './unknownContextProviderRule'
+
+describe('unknownContextProviderRule', () => {
+  test('should detect context from component that does not exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                unknown: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'unknown',
+                },
+              },
+            },
+            provider: {
+              name: 'provider',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownContextProviderRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown context provider')
+  })
+
+  test('should not detect when context exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            consumer: {
+              name: 'consumer',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              contexts: {
+                provider: {
+                  formulas: ['test'],
+                  workflows: ['test'],
+                  componentName: 'provider',
+                },
+              },
+            },
+            provider: {
+              name: 'provider',
+              nodes: {},
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownContextProviderRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/context/unknownContextProviderRule.ts

@@ -0,0 +1,30 @@
+import type { Rule } from '../../types'
+
+export const unknownContextProviderRule: Rule<{ componentName: string }> = {
+  code: 'unknown context provider',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'component-context') {
+      return
+    }
+
+    if (!value.componentName) {
+      return
+    }
+
+    if (value.package) {
+      const _package = files.packages?.[value.package]
+      if (_package?.components[value.componentName]) {
+        return
+      }
+    } else {
+      const component = files.components[value.componentName]
+      if (component) {
+        return
+      }
+    }
+
+    report(path, { componentName: value.componentName })
+  },
+}

package/src/rules/dom/createRequiredDirectChildRule.test.ts

@@ -0,0 +1,119 @@
+import { searchProject } from '../../searchProject'
+import { createRequiredDirectChildRule } from './createRequiredDirectChildRule'
+
+describe('createRequiredDirectChildRule', () => {
+  test('should detect wrong direct children', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'ul',
+                  children: ['child1', 'child2'],
+                  style: {},
+                },
+                child1: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'p',
+                  children: [],
+                  style: {},
+                },
+                child2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'img',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [createRequiredDirectChildRule(['ul'], ['li'])],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('required direct child')
+    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'child1'])
+    expect(problems[0].details).toEqual({
+      parentTag: 'ul',
+      childTag: 'p',
+      allowedChildTags: ['li'],
+    })
+    expect(problems[1].code).toBe('required direct child')
+    expect(problems[1].path).toEqual(['components', 'test', 'nodes', 'child2'])
+    expect(problems[1].details).toEqual({
+      parentTag: 'ul',
+      childTag: 'img',
+      allowedChildTags: ['li'],
+    })
+  })
+  test('should not detect valid direct children', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'ul',
+                  children: ['child1', 'child2'],
+                  style: {},
+                },
+                child1: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'li',
+                  children: [],
+                  style: {},
+                },
+                child2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'li',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [createRequiredDirectChildRule(['ul'], ['li'])],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+})

package/src/rules/dom/createRequiredDirectChildRule.ts

@@ -0,0 +1,43 @@
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import type { Level, Rule } from '../../types'
+
+export function createRequiredDirectChildRule(
+  parentTags: string[],
+  childTags: string[],
+  level: Level = 'warning',
+): Rule<{
+  parentTag: string
+  childTag: string
+  allowedChildTags: string[]
+}> {
+  return {
+    code: 'required direct child',
+    level,
+    category: 'Accessibility',
+    visit: (report, args) => {
+      if (args.nodeType !== 'component-node') {
+        return
+      }
+      const { value, component, path } = args
+      if (value.type !== 'element' || !parentTags.includes(value.tag)) {
+        return
+      }
+      const getElement = (id: string): NodeModel | undefined =>
+        component.nodes[id]
+      value.children.forEach((childId) => {
+        const childNode = getElement(childId)
+        if (
+          childNode &&
+          childNode.type === 'element' &&
+          !childTags.includes(childNode.tag)
+        ) {
+          report([...path.slice(0, 3), childId], {
+            parentTag: value.tag,
+            childTag: childNode.tag,
+            allowedChildTags: childTags,
+          })
+        }
+      })
+    },
+  }
+}