@nordcraft/search 1.0.52 → 1.0.54

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

@@ -1,170 +0,0 @@
-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/slots/unknownComponentSlotRule.ts

@@ -1,50 +0,0 @@
-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 })
-      }
-    })
-  },
-}

package/src/rules/style/invalidStyleSyntaxRule.test.ts

@@ -1,106 +0,0 @@
-import type { ElementNodeModel } from '@nordcraft/core/dist/component/component.types'
-import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
-import { describe, expect, test } from 'bun:test'
-import { fixProject } from '../../fixProject'
-import { searchProject } from '../../searchProject'
-import { invalidStyleSyntaxRule } from './invalidStyleSyntaxRule'
-
-describe('find invalidStyleSyntaxRule', () => {
-  test('should find invalid style syntax', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  tag: 'ul',
-                  type: 'element',
-                  attrs: {},
-                  style: {
-                    gap: '8px',
-                    width: '100%',
-                    'max-width': 'calc(NOT VALID',
-                    height: '/* 100px */ 22px',
-                    '{': '100px',
-                    'border-width': '--my-var',
-                  },
-                  events: {},
-                  classes: {},
-                  children: [],
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [invalidStyleSyntaxRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('invalid style syntax')
-    expect(problems[0].path).toEqual([
-      'components',
-      'test',
-      'nodes',
-      'root',
-      'style',
-      'max-width',
-    ])
-    expect(problems[0].details.property).toBe('max-width')
-    expect(problems[1].details.property).toBe('{')
-  })
-})
-
-describe('fix invalidStyleSyntaxRule', () => {
-  test('should remove an invalid style property', () => {
-    const files: ProjectFiles = {
-      formulas: {},
-      components: {
-        test: {
-          name: 'test',
-          nodes: {
-            root: {
-              tag: 'ul',
-              type: 'element',
-              attrs: {},
-              style: {
-                gap: '8px',
-                width: '100%',
-                'max-width': 'calc(NOT VALID',
-                height: '/* 100px */ 22px',
-                '{': '100px',
-              },
-              events: {},
-              classes: {},
-              children: [],
-            },
-          },
-          formulas: {},
-          apis: {},
-          attributes: {},
-          variables: {},
-        },
-      },
-    }
-    const fixedFiles = fixProject({
-      files,
-      rule: invalidStyleSyntaxRule,
-      fixType: 'delete-style-property',
-    })
-    expect((fixedFiles.components.test!.nodes.root as ElementNodeModel).style)
-      .toMatchInlineSnapshot(`
-      {
-        "gap": "8px",
-        "height": "/* 100px */ 22px",
-        "width": "100%",
-      }
-    `)
-  })
-})

package/src/rules/style/invalidStyleSyntaxRule.ts

@@ -1,35 +0,0 @@
-import { parse } from 'postcss'
-import type { Rule } from '../../types'
-import { removeFromPathFix } from '../../util/removeUnused.fix'
-
-export const invalidStyleSyntaxRule: Rule<{
-  property: string
-}> = {
-  code: 'invalid style syntax',
-  level: 'error',
-  category: 'Quality',
-  visit: (report, { nodeType, value, path, memo }) => {
-    if (nodeType !== 'style-declaration') {
-      return
-    }
-    const valid = memo(
-      `valid-style-${value.styleProperty}:${value.styleValue}`,
-      () => {
-        try {
-          parse(`${value.styleProperty}: ${value.styleValue}`)
-          return true
-        } catch {
-          return false
-        }
-      },
-    )
-    if (!valid) {
-      report(path, { property: value.styleProperty }, ['delete-style-property'])
-    }
-  },
-  fixes: {
-    'delete-style-property': removeFromPathFix,
-  },
-}
-
-export type InvalidStyleSyntaxRuleFix = 'delete-style-property'

package/src/rules/unknownCookieRule.test.ts

@@ -1,112 +0,0 @@
-import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../searchProject'
-import { unknownCookieRule } from './unknownCookieRule'
-
-describe('unknownCookie', () => {
-  test('should report unknown cookies', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {
-                'my-api': {
-                  name: 'my-api',
-                  type: 'http',
-                  version: 2,
-                  autoFetch: valueFormula(true),
-                  inputs: {},
-                  headers: {
-                    Authorization: {
-                      formula: {
-                        type: 'function',
-                        name: '@toddle/getHttpOnlyCookie',
-                        arguments: [
-                          {
-                            formula: {
-                              type: 'value',
-                              value: 'unknown',
-                            },
-                          },
-                        ],
-                      },
-                    },
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [unknownCookieRule],
-        state: {
-          cookiesAvailable: [{ name: 'known' } as any],
-          isBrowserExtensionAvailable: true,
-        },
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('unknown cookie')
-  })
-  test('should not report known cookies', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {
-                'my-api': {
-                  name: 'my-api',
-                  type: 'http',
-                  version: 2,
-                  autoFetch: valueFormula(true),
-                  inputs: {},
-                  headers: {
-                    Authorization: {
-                      formula: {
-                        type: 'function',
-                        name: '@toddle/getHttpOnlyCookie',
-                        arguments: [
-                          {
-                            formula: {
-                              type: 'value',
-                              value: 'known',
-                            },
-                          },
-                        ],
-                      },
-                    },
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [unknownCookieRule],
-        state: {
-          cookiesAvailable: [{ name: 'known' } as any],
-          isBrowserExtensionAvailable: true,
-        },
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/unknownCookieRule.ts

@@ -1,34 +0,0 @@
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../types'
-
-export const unknownCookieRule: Rule<{
-  name: string
-}> = {
-  code: 'unknown cookie',
-  level: 'info',
-  category: 'Unknown Reference',
-  visit: (report, { path, value, nodeType }, state) => {
-    if (
-      nodeType !== 'formula' ||
-      value.type !== 'function' ||
-      value.name !== '@toddle/getHttpOnlyCookie' ||
-      value.arguments.length !== 1 ||
-      !state ||
-      state.isBrowserExtensionAvailable !== true
-    ) {
-      return
-    }
-    const formula = value.arguments[0]?.formula
-    if (
-      !isDefined(formula) ||
-      formula.type !== 'value' ||
-      typeof formula.value !== 'string'
-    ) {
-      return
-    }
-    const cookie = state.cookiesAvailable?.find((c) => c.name === formula.value)
-    if (!cookie) {
-      report(path, { name: formula.value })
-    }
-  },
-}

package/src/rules/urlParameters/duplicateUrlParameterRule.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { duplicateUrlParameterRule } from './duplicateUrlParameterRule'
-
-describe('duplicateUrlParameterRule', () => {
-  test('should detect duplicate URL parameters', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  {
-                    type: 'param',
-                    name: 'id',
-                    testValue: '1',
-                  },
-                  {
-                    type: 'static',
-                    name: 'name',
-                  },
-                ],
-                query: {
-                  id: {
-                    name: 'id',
-                    testValue: '1',
-                  },
-                },
-              },
-            },
-          },
-        },
-        rules: [duplicateUrlParameterRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('duplicate url parameter')
-    expect(problems[0].path).toEqual([
-      'components',
-      'test',
-      'route',
-      'query',
-      'id',
-    ])
-    expect(problems[0].details).toEqual({ name: 'id' })
-  })
-  test('should detect duplicate path parameters', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  {
-                    type: 'param',
-                    name: 'company',
-                    testValue: '1',
-                  },
-                  {
-                    type: 'static',
-                    name: 'company',
-                  },
-                ],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [duplicateUrlParameterRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('duplicate url parameter')
-    expect(problems[0].path).toEqual(['components', 'test', 'route', 'path', 1])
-    expect(problems[0].details).toEqual({ name: 'company' })
-  })
-  test('should not detect non-duplicate URL parameters', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  {
-                    type: 'param',
-                    name: 'id',
-                    testValue: '1',
-                  },
-                  {
-                    type: 'static',
-                    name: 'name',
-                  },
-                ],
-                query: {
-                  other: {
-                    name: 'other',
-                    testValue: '1',
-                  },
-                },
-              },
-            },
-          },
-        },
-        rules: [duplicateUrlParameterRule],
-      }),
-    )
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/urlParameters/duplicateUrlParameterRule.ts

@@ -1,30 +0,0 @@
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../../types'
-
-export const duplicateUrlParameterRule: Rule<{ name: string }> = {
-  code: 'duplicate url parameter',
-  level: 'warning',
-  category: 'Quality',
-  visit: (report, { nodeType, path, value }) => {
-    if (
-      nodeType !== 'component' ||
-      !isDefined(value.route) ||
-      !isDefined(value.route.path) ||
-      !isDefined(value.route.query)
-    ) {
-      return
-    }
-    const pathNames = new Set<string>()
-    value.route.path.forEach((p, i) => {
-      if (pathNames.has(p.name)) {
-        report([...path, 'route', 'path', i], { name: p.name })
-      }
-      pathNames.add(p.name)
-    })
-    Object.keys(value.route.query).forEach((key) => {
-      if (pathNames.has(key)) {
-        report([...path, 'route', 'query', key], { name: key })
-      }
-    })
-  },
-}