@nordcraft/search 1.0.53 → 1.0.54

package/src/rules/issues/routing/unknownSetUrlParametersRule.test.ts

@@ -0,0 +1,160 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownSetUrlParametersRule } from './unknownSetUrlParametersRule'
+
+describe('unknownSetUrlParametersRule', () => {
+  test('should report setting unknown URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameters',
+                          parameters: { unknown: valueFormula('newValue') },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownSetUrlParametersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameters')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should report setting static path parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameters',
+                          parameters: { knownPath: valueFormula('newValue') },
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [
+                  {
+                    name: 'knownPath',
+                    type: 'static',
+                  },
+                ],
+                query: {},
+              },
+            },
+          },
+        },
+        rules: [unknownSetUrlParametersRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown set url parameters')
+    expect(problems[0].details).toEqual({ name: 'knownPath' })
+  })
+
+  test('should not report valid url updates', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-query',
+                          data: valueFormula('newValue'),
+                        },
+                        {
+                          type: 'SetURLParameter',
+                          parameter: 'known-path',
+                          data: valueFormula('newValue'),
+                        },
+                      ],
+                    },
+                  },
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [{ name: 'known-path', type: 'param', testValue: 'bla' }],
+                query: {
+                  'known-query': {
+                    name: 'known-query',
+                    testValue: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownSetUrlParametersRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/routing/unknownSetUrlParametersRule.ts

@@ -0,0 +1,34 @@
+import type { Rule } from '../../../types'
+
+export const unknownSetUrlParametersRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown set url parameters',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, args) => {
+    if (
+      args.nodeType !== 'action-model' ||
+      args.value.type !== 'SetURLParameters'
+    ) {
+      return
+    }
+    const isValidParameter = (parameterName: string) =>
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      args.component.route?.path?.some(
+        (p) =>
+          p.name === parameterName &&
+          // It's only valid to set non-static path parameters
+          p.type === 'param',
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      ) ||
+      Object.values(args.component.route?.query ?? {}).some(
+        (q) => q.name === parameterName,
+      )
+    for (const key of Object.keys(args.value.parameters ?? {})) {
+      if (!isValidParameter(key)) {
+        report([...args.path, 'parameters', key], { name: key })
+      }
+    }
+  },
+}

package/src/rules/issues/routing/unknownUrlParameterRule.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownUrlParameterRule } from './unknownUrlParameterRule'
+
+describe('unknownUrlParameterRule', () => {
+  test('should report reading unknown URL parameters', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'unknown'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown url parameter')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report url parameters that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'known-path'],
+                      },
+                    },
+                    'my-other-class': {
+                      formula: {
+                        type: 'path',
+                        path: ['URL parameters', 'known-query'],
+                      },
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+              route: {
+                path: [{ name: 'known-path', type: 'static' }],
+                query: {
+                  'known-query': {
+                    name: 'known-query',
+                    testValue: '',
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [unknownUrlParameterRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/routing/unknownUrlParameterRule.ts

@@ -0,0 +1,28 @@
+import type { Rule } from '../../../types'
+
+export const unknownUrlParameterRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown url parameter',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (
+      nodeType !== 'formula' ||
+      value.type !== 'path' ||
+      value.path[0] !== 'URL parameters'
+    ) {
+      return
+    }
+
+    const [, componentName] = path
+    const [, parameterKey] = value.path
+    const component = files.components[componentName]
+    if (
+      !component?.route?.query?.[parameterKey] &&
+      !component?.route?.path?.some((p) => p.name === parameterKey)
+    ) {
+      report(path, { name: parameterKey })
+    }
+  },
+}

package/src/rules/issues/slots/slotRules.index.ts

@@ -0,0 +1,4 @@
+import { unknownClassnameRule } from './unknownClassnameRule'
+import { unknownComponentSlotRule } from './unknownComponentSlotRule'
+
+export default [unknownClassnameRule, unknownComponentSlotRule]

package/src/rules/issues/slots/unknownClassnameRule.test.ts

@@ -0,0 +1,94 @@
+import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownClassnameRule } from './unknownClassnameRule'
+
+describe('unknownClassname', () => {
+  test('should report referencing unknown classnames', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: valueFormula(true),
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  variants: [
+                    {
+                      className: 'unknown',
+                      breakpoint: 'small',
+                      style: {},
+                    },
+                  ],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownClassnameRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('unknown classname')
+    expect(problems[0].details).toEqual({ name: 'unknown' })
+  })
+
+  test('should not report classnames that exist', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {
+                    'my-class': {
+                      formula: valueFormula(true),
+                    },
+                  },
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  variants: [
+                    {
+                      className: 'my-class',
+                      breakpoint: 'small',
+                      style: {},
+                    },
+                  ],
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownClassnameRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

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

@@ -0,0 +1,21 @@
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { Rule } from '../../../types'
+
+export const unknownClassnameRule: Rule<{
+  name: string
+}> = {
+  code: 'unknown classname',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, value, nodeType }) => {
+    if (
+      nodeType !== 'style-variant' ||
+      typeof value.variant.className !== 'string' ||
+      value.element.type !== 'element' ||
+      isDefined(value.element.classes[value.variant.className])
+    ) {
+      return
+    }
+    report(path, { name: value.variant.className })
+  },
+}

package/src/rules/issues/slots/unknownComponentSlotRule.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, test } from 'bun:test'
+import { searchProject } from '../../../searchProject'
+import { unknownComponentSlotRule } from './unknownComponentSlotRule'
+
+describe('unknownComponentSlotRule', () => {
+  test('should detect elements in unknown component slots', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            noSlotComponent: {
+              name: 'noSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            attemptToUseNoSlotComponent: {
+              name: 'attemptToUseNoSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: ['noSlotComponent'],
+                  style: {},
+                },
+                noSlotComponent: {
+                  name: 'noSlotComponent',
+                  attrs: {},
+                  events: {},
+                  type: 'component',
+                  children: ['divInUnknownSlot', 'divInUnknownSlot2'],
+                },
+                divInUnknownSlot: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                divInUnknownSlot2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  slot: 'unknown',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentSlotRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(2)
+    expect(problems[0].code).toBe('unknown component slot')
+    expect(problems[0].details).toEqual({ slotName: 'default' })
+    expect(problems[1].code).toBe('unknown component slot')
+    expect(problems[1].details).toEqual({ slotName: 'unknown' })
+  })
+
+  test('should pass when using existing slots', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          components: {
+            slotComponent: {
+              name: 'slotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                default: {
+                  type: 'slot',
+                  children: [],
+                },
+                slot: {
+                  type: 'slot',
+                  children: [],
+                  name: 'slot',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+            attemptToUseSlotComponent: {
+              name: 'attemptToUseSlotComponent',
+              nodes: {
+                root: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: ['slotComponent'],
+                  style: {},
+                },
+                slotComponent: {
+                  name: 'slotComponent',
+                  attrs: {},
+                  events: {},
+                  type: 'component',
+                  children: ['divInKnownSlot', 'divInKnownSlot2'],
+                },
+                divInKnownSlot: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                },
+                divInKnownSlot2: {
+                  type: 'element',
+                  attrs: {},
+                  classes: {},
+                  events: {},
+                  tag: 'div',
+                  children: [],
+                  style: {},
+                  slot: 'slot',
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [unknownComponentSlotRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})

package/src/rules/issues/slots/unknownComponentSlotRule.ts

@@ -0,0 +1,50 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import type { SlotNodeModel } from '@nordcraft/core/dist/component/component.types'
+import type { Rule } from '../../../types'
+
+export const unknownComponentSlotRule: Rule<{ slotName: string }> = {
+  code: 'unknown component slot',
+  level: 'error',
+  category: 'Unknown Reference',
+  visit: (report, { path, files, value, nodeType }) => {
+    if (nodeType !== 'component-node') {
+      return
+    }
+
+    // We only want to check the immediate children of a "sub component"
+    if (value.type !== 'component' || value.children.length === 0) {
+      return
+    }
+
+    const [, currentComponentName, ,] = path
+
+    const component = files.components[value.name]
+    if (!component) {
+      return
+    }
+    // Load the component to get the slots
+    const subComponent = new ToddleComponent({
+      component,
+      getComponent: (name) => files.components[name],
+      packageName: undefined,
+      globalFormulas: {
+        formulas: files.formulas,
+        packages: files.packages,
+      },
+    })
+
+    const usableSlots = Object.values(subComponent.nodes)
+      .filter((node): node is SlotNodeModel => node.type === 'slot')
+      .map((node) => node.name ?? 'default')
+
+    // Loop the children and report issue when using a slot that doesn't exist
+    value.children.forEach((child) => {
+      const childNode = files.components[currentComponentName]?.nodes[child]
+      const usedSlot = childNode?.slot ?? 'default'
+
+      if (!usableSlots.includes(usedSlot)) {
+        report([path[0], path[1], path[2], child], { slotName: usedSlot })
+      }
+    })
+  },
+}