@nordcraft/search 1.0.53 → 1.0.54

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

@@ -1,83 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { nonEmptyVoidElementRule } from './nonEmptyVoidElementRule'
-
-describe('voidElementRule', () => {
-  test('should detect void elements with children', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {},
-                  tag: 'img',
-                  children: ['other'],
-                  style: {},
-                },
-                other: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {},
-                  tag: 'p',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [nonEmptyVoidElementRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('non-empty void element')
-    expect(problems[0].details).toEqual({ tag: 'img' })
-    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'root'])
-  })
-
-  test('should not detect void elements with no children', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {},
-                  tag: 'input',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [nonEmptyVoidElementRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/dom/nonEmptyVoidElementRule.ts

@@ -1,22 +0,0 @@
-import { VOID_HTML_ELEMENTS } from '@nordcraft/ssr/dist/const'
-import type { Rule } from '../../types'
-/**
- * See full list here
- * https://developer.mozilla.org/en-US/docs/Glossary/Void_element
- */
-export const nonEmptyVoidElementRule: Rule<{ tag: string }> = {
-  code: 'non-empty void element',
-  level: 'warning',
-  category: 'Quality',
-  visit: (report, { path, nodeType, value }) => {
-    if (
-      nodeType !== 'component-node' ||
-      value.type !== 'element' ||
-      value.children.length <= 0 ||
-      !VOID_HTML_ELEMENTS.includes(value.tag)
-    ) {
-      return
-    }
-    report(path, { tag: value.tag })
-  },
-}

package/src/rules/duplicateRouteRule.test.ts

@@ -1,147 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../searchProject'
-import { duplicateRouteRule } from './duplicateRouteRule'
-
-describe('duplicateRouteRule', () => {
-  test('should detect duplicate route declarations', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            home: {
-              name: 'home',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [],
-                query: {},
-              },
-            },
-            home2: {
-              name: 'home2',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [],
-                query: {},
-              },
-            },
-          },
-          routes: {},
-        },
-        rules: [duplicateRouteRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('duplicate route')
-    expect(problems[0].details.name).toEqual('home')
-    expect(problems[0].details.type).toEqual('page')
-    expect(problems[0].details.duplicates).toEqual([
-      { name: 'home2', type: 'page' },
-    ])
-    expect(problems[0].path).toEqual(['components', 'home', 'route', 'path'])
-  })
-  test('should detect non-basic duplicate route declarations', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            home: {
-              name: 'home',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  { type: 'static', name: 'blog' },
-                  { type: 'param', name: 'slug', testValue: 'my-blog' },
-                ],
-                query: {},
-              },
-            },
-            home2: {
-              name: 'home2',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  { type: 'static', name: 'blog' },
-                  { type: 'param', name: 'param', testValue: 'my-blog' },
-                ],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [duplicateRouteRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('duplicate route')
-    expect(problems[0].details.name).toEqual('home')
-    expect(problems[0].details.type).toEqual('page')
-    expect(problems[0].details.duplicates).toEqual([
-      { name: 'home2', type: 'page' },
-    ])
-    expect(problems[0].path).toEqual(['components', 'home', 'route', 'path'])
-  })
-  test('should not detect unique route declarations', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            home: {
-              name: 'home',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [],
-                query: {},
-              },
-            },
-            home2: {
-              name: 'home2',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                path: [
-                  {
-                    name: 'blogs',
-                    type: 'static',
-                  },
-                ],
-                query: {},
-              },
-            },
-          },
-          routes: {},
-        },
-        rules: [duplicateRouteRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/duplicateRouteRule.ts

@@ -1,52 +0,0 @@
-import type { RouteDeclaration } from '@nordcraft/core/dist/component/component.types'
-import { isPageComponent } from '@nordcraft/core/dist/component/isPageComponent'
-import type { Rule } from '../types'
-
-export const duplicateRouteRule: Rule<{
-  name: string
-  type: 'route' | 'page'
-  duplicates: Array<{ name: string; type: 'route' | 'page' }>
-}> = {
-  code: 'duplicate route',
-  level: 'warning',
-  category: 'Quality',
-  visit: (report, args) => {
-    const { nodeType, value, files, memo, path } = args
-    if (nodeType !== 'component' || !isPageComponent(value)) {
-      return
-    }
-    const getRouteKey = (route: RouteDeclaration['path']) =>
-      route.reduce(
-        (acc, part) => `${acc}/${part.type === 'static' ? part.name : '*'}`,
-        '/',
-      )
-    const allRoutes = memo('allRoutes', () => {
-      const routes = new Map<string, string[]>()
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      Object.entries(files.components ?? {}).map(
-        ([component, componentValue]) => {
-          if (componentValue && isPageComponent(componentValue)) {
-            const key = getRouteKey(componentValue.route.path)
-            const existing = routes.get(key)
-            if (existing) {
-              existing.push(component)
-            } else {
-              routes.set(key, [component])
-            }
-          }
-        },
-      )
-      return routes
-    })
-    const match = allRoutes.get(getRouteKey(value.route?.path))
-    if (match && match.length > 1) {
-      report([...path, 'route', 'path'], {
-        name: value.name,
-        type: 'page',
-        duplicates: match
-          .filter((m) => m !== value.name)
-          .map((name) => ({ name, type: 'page' })),
-      })
-    }
-  },
-}

package/src/rules/events/duplicateEventTriggerRule.test.ts

@@ -1,98 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { duplicateEventTriggerRule } from './duplicateEventTriggerRule'
-
-describe('duplicateEventTriggerRule', () => {
-  test('should detect duplicate event triggers', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                n1: {
-                  type: 'element',
-                  tag: 'button',
-                  events: {
-                    click: {
-                      trigger: 'click',
-                      actions: [],
-                    },
-                    otherEvent: {
-                      trigger: 'click',
-                      actions: [],
-                    },
-                  },
-                  attrs: {},
-                  style: {},
-                  children: [],
-                  classes: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [duplicateEventTriggerRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('duplicate event trigger')
-    expect(problems[0].details).toEqual({ trigger: 'click' })
-    expect(problems[0].path).toEqual([
-      'components',
-      'test',
-      'nodes',
-      'n1',
-      'events',
-      'otherEvent',
-    ])
-  })
-  test('should not detect events that do not have duplicate triggers', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                n1: {
-                  type: 'element',
-                  tag: 'button',
-                  events: {
-                    click: {
-                      trigger: 'click',
-                      actions: [],
-                    },
-                    otherEvent: {
-                      trigger: 'mouseenter',
-                      actions: [],
-                    },
-                  },
-                  attrs: {},
-                  style: {},
-                  children: [],
-                  classes: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [duplicateEventTriggerRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/events/duplicateEventTriggerRule.ts

@@ -1,24 +0,0 @@
-import type { Rule } from '../../types'
-
-export const duplicateEventTriggerRule: Rule<{ trigger: string }> = {
-  code: 'duplicate event trigger',
-  level: 'warning',
-  category: 'Quality',
-  visit: (report, { nodeType, path, value }) => {
-    if (nodeType !== 'component-node' || value.type !== 'element') {
-      return
-    }
-    const eventTriggers = new Set<string>()
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    Object.entries(value.events ?? {}).forEach(([key, event]) => {
-      if (typeof event?.trigger !== 'string') {
-        return
-      }
-      if (eventTriggers.has(event.trigger)) {
-        report([...path, 'events', key], { trigger: event.trigger })
-      }
-      eventTriggers.add(event.trigger)
-    })
-  },
-}

package/src/rules/events/noReferenceEventRule.test.ts

@@ -1,206 +0,0 @@
-import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
-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 { noReferenceEventRule } from './noReferenceEventRule'
-
-describe('find noReferenceEventRule', () => {
-  test('should detect events with no references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {
-                    click: {
-                      trigger: 'click',
-                      actions: [
-                        {
-                          type: 'TriggerEvent',
-                          event: 'unknown-event',
-                          data: valueFormula(null),
-                        },
-                      ],
-                    },
-                  },
-                  tag: 'div',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              events: [
-                {
-                  name: 'unused-event',
-                  // eslint-disable-next-line inclusive-language/use-inclusive-words
-                  dummyEvent: {
-                    name: 'Name',
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              ],
-            },
-          },
-        },
-        rules: [noReferenceEventRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference event')
-    expect(problems[0].path).toEqual(['components', 'test', 'events', 0])
-    expect(problems[0].details).toEqual({ name: 'unused-event' })
-  })
-
-  test('should not detect events with references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {
-                    click: {
-                      trigger: 'click',
-                      actions: [
-                        {
-                          type: 'TriggerEvent',
-                          event: 'known-event',
-                          data: valueFormula(null),
-                        },
-                        {
-                          name: 'TriggerEvent',
-                          events: {},
-                          arguments: [
-                            {
-                              name: 'name',
-                              formula: {
-                                type: 'value',
-                                value: 'used-event',
-                              },
-                            },
-                            {
-                              name: 'data',
-                              formula: {
-                                type: 'value',
-                                value: 'TestValue',
-                              },
-                            },
-                          ],
-                        },
-                      ],
-                    },
-                  },
-                  tag: 'div',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              events: [
-                {
-                  name: 'known-event',
-                  // eslint-disable-next-line inclusive-language/use-inclusive-words
-                  dummyEvent: {
-                    name: 'Name',
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-                {
-                  name: 'used-event',
-                  // eslint-disable-next-line inclusive-language/use-inclusive-words
-                  dummyEvent: {
-                    name: 'Name',
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              ],
-            },
-          },
-        },
-        rules: [noReferenceEventRule],
-      }),
-    )
-    expect(problems).toEqual([])
-  })
-})
-
-describe('fix noReferenceEventRule', () => {
-  test('should remove events with no references', () => {
-    const files: ProjectFiles = {
-      components: {
-        test: {
-          name: 'test',
-          nodes: {
-            root: {
-              type: 'element',
-              attrs: {},
-              classes: {},
-              events: {
-                click: {
-                  trigger: 'click',
-                  actions: [
-                    {
-                      type: 'TriggerEvent',
-                      event: 'unknown-event',
-                      data: valueFormula(null),
-                    },
-                  ],
-                },
-              },
-              tag: 'div',
-              children: [],
-              style: {},
-            },
-          },
-          formulas: {},
-          apis: {},
-          attributes: {},
-          variables: {},
-          events: [
-            {
-              name: 'unused-event',
-              // eslint-disable-next-line inclusive-language/use-inclusive-words
-              dummyEvent: {
-                name: 'Name',
-              },
-              '@nordcraft/metadata': {
-                comments: null,
-              },
-            },
-          ],
-        },
-      },
-    }
-    const fixedFiles = fixProject({
-      files,
-      rule: noReferenceEventRule,
-      fixType: 'delete-event',
-    })
-    expect(fixedFiles.components['test']?.events).toEqual([])
-  })
-})

package/src/rules/events/noReferenceEventRule.ts

@@ -1,51 +0,0 @@
-import type { Rule } from '../../types'
-import { isLegacyAction } from '../../util/helpers'
-import { removeFromPathFix } from '../../util/removeUnused.fix'
-
-export const noReferenceEventRule: Rule<{ name: string }> = {
-  code: 'no-reference event',
-  level: 'warning',
-  category: 'No References',
-  visit: (report, args) => {
-    if (args.nodeType !== 'component-event') {
-      return
-    }
-    const { memo, value } = args
-    const { component, event } = value
-    const events = memo(`${component.name}-events`, () => {
-      const events = new Set<string>()
-      for (const [, action] of component.actionModelsInComponent()) {
-        if (isLegacyAction(action)) {
-          if (
-            'name' in action &&
-            'arguments' in action &&
-            action.name === 'TriggerEvent' &&
-            action.version === undefined
-          ) {
-            const formula = action.arguments?.find(
-              (a) => a?.name === 'name',
-            )?.formula
-            if (
-              formula?.type === 'value' &&
-              typeof formula.value === 'string'
-            ) {
-              events.add(formula.value)
-            }
-          }
-        } else if (action.type === 'TriggerEvent') {
-          events.add(action.event)
-        }
-      }
-      return events
-    })
-    if (events.has(event.name)) {
-      return
-    }
-    report(args.path, { name: args.value.event.name }, ['delete-event'])
-  },
-  fixes: {
-    'delete-event': removeFromPathFix,
-  },
-}
-
-export type NoReferenceEventRuleFix = 'delete-event'