@nordcraft/search 1.0.53 → 1.0.54

package/src/rules/attributes/unknownComponentAttributeRule.ts

@@ -1,37 +0,0 @@
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../../types'
-import { removeFromPathFix } from '../../util/removeUnused.fix'
-
-export const unknownComponentAttributeRule: Rule<{
-  name: string
-  componentName: string
-}> = {
-  code: 'unknown component attribute',
-  level: 'error',
-  category: 'Unknown Reference',
-  visit: (report, args) => {
-    if (
-      args.nodeType !== 'component-node-attribute' ||
-      args.node.type !== 'component'
-    ) {
-      return
-    }
-    const { files, value, node, path } = args
-    const component = node.package
-      ? files.packages?.[node.package].components?.[node.name]
-      : files.components[node.name]
-    if (!component) {
-      return
-    }
-    if (!isDefined(component.attributes?.[value.key])) {
-      report(path, { name: value.key, componentName: node.name }, [
-        'delete-component-attribute',
-      ])
-    }
-  },
-  fixes: {
-    'delete-component-attribute': removeFromPathFix,
-  },
-}
-
-export type UnknownComponentAttributeRuleFix = 'delete-component-attribute'

package/src/rules/components/noReferenceComponentRule.test.ts

@@ -1,301 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { fixProject } from '../../fixProject'
-import { searchProject } from '../../searchProject'
-import { noReferenceComponentRule } from './noReferenceComponentRule'
-
-describe('detect noReferenceComponentRule', () => {
-  test('should detect components with no references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            orphan: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-            exportedOrphan: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              exported: true,
-            },
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentRule],
-        state: {
-          projectDetails: {
-            type: 'package',
-            id: 'test-project-id',
-            name: 'test-project',
-            short_id: 'test-project-id',
-          },
-        },
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component')
-    expect(problems[0].path).toEqual(['components', 'orphan'])
-  })
-  test('should detect components that are only referenced by themselves', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            orphan: {
-              name: 'test',
-              nodes: {
-                abc: {
-                  type: 'component',
-                  attrs: {},
-                  children: [],
-                  name: 'test',
-                  events: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component')
-    expect(problems[0].path).toEqual(['components', 'orphan'])
-  })
-
-  test('should not detect components with references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            abcd: {
-              name: 'my-component',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-            page: {
-              name: 'my-page',
-              nodes: {
-                root: {
-                  type: 'component',
-                  name: 'my-component',
-                  attrs: {},
-                  children: [],
-                  events: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should not report exported components for package projects', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            orphan: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              exported: true,
-            },
-          },
-        },
-        state: {
-          projectDetails: {
-            type: 'package',
-            id: 'test-package-id',
-            name: 'test-package',
-            short_id: 'test-package-id',
-          },
-        },
-        rules: [noReferenceComponentRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should still report exported components for non-package projects', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            exportedOrphan: {
-              name: 'test',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              exported: true,
-            },
-          },
-        },
-        state: {
-          projectDetails: {
-            type: 'app',
-            id: 'test-project-id',
-            name: 'test-project',
-            short_id: 'test-project-id',
-          },
-        },
-        rules: [noReferenceComponentRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component')
-    expect(problems[0].path).toEqual(['components', 'exportedOrphan'])
-  })
-})
-
-describe('fix noReferenceComponentRule', () => {
-  test('should remove components with no references', () => {
-    const fixedProject = fixProject({
-      files: {
-        formulas: {},
-        components: {
-          orphan: {
-            name: 'test',
-            nodes: {},
-            formulas: {},
-            apis: {},
-            attributes: {},
-            variables: {},
-          },
-          anotherOrphan: {
-            name: 'test 2',
-            nodes: {},
-            formulas: {},
-            apis: {},
-            attributes: {},
-            variables: {},
-          },
-          exportedOrphan: {
-            name: 'test',
-            nodes: {},
-            formulas: {},
-            apis: {},
-            attributes: {},
-            variables: {},
-            exported: true,
-          },
-          page: {
-            name: 'my-page',
-            nodes: {},
-            formulas: {},
-            apis: {},
-            attributes: {},
-            variables: {},
-            route: {
-              info: {},
-              path: [],
-              query: {},
-            },
-          },
-        },
-      },
-      rule: noReferenceComponentRule,
-      fixType: 'delete-component',
-      state: {
-        projectDetails: {
-          type: 'package',
-          id: 'test-project-id',
-          name: 'test-project',
-          short_id: 'test-project-id',
-        },
-      },
-    })
-    // The orphan component should no longer exist
-    expect(fixedProject.components).toEqual({
-      exportedOrphan: {
-        name: 'test',
-        nodes: {},
-        formulas: {},
-        apis: {},
-        attributes: {},
-        variables: {},
-        exported: true,
-      },
-      page: {
-        name: 'my-page',
-        nodes: {},
-        formulas: {},
-        apis: {},
-        attributes: {},
-        variables: {},
-        route: {
-          info: {},
-          path: [],
-          query: {},
-        },
-      },
-    })
-  })
-})

package/src/rules/components/noReferenceComponentRule.ts

@@ -1,45 +0,0 @@
-import type { Component } from '@nordcraft/core/dist/component/component.types'
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../../types'
-import { removeFromPathFix } from '../../util/removeUnused.fix'
-
-export const noReferenceComponentRule: Rule<void> = {
-  code: 'no-reference component',
-  level: 'warning',
-  category: 'No References',
-  visit: (report, data, state) => {
-    if (
-      data.nodeType !== 'component' ||
-      isPage(data.value) ||
-      (state?.projectDetails?.type === 'package' &&
-        data.value.exported === true)
-    ) {
-      return
-    }
-    for (const component of Object.values(data.files.components)) {
-      // Enforce that the component is not undefined since we're iterating
-      for (const node of Object.values(component!.nodes ?? {})) {
-        if (
-          node.type === 'component' &&
-          node.name === data.value.name &&
-          // Circular references from a component to itself should
-          // not count as a reference
-          node.name !== component!.name
-        ) {
-          return
-        }
-      }
-    }
-    report(data.path, undefined, ['delete-component'])
-  },
-  fixes: {
-    'delete-component': removeFromPathFix,
-  },
-}
-
-export type NoReferenceComponentRuleFix = 'delete-component'
-
-const isPage = (
-  value: Component,
-): value is Component & { route: Required<Component['route']> } =>
-  isDefined(value.route)

package/src/rules/components/unknownComponentRule.test.ts

@@ -1,115 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { unknownComponentRule } from './unknownComponentRule'
-
-describe('unknownComponent', () => {
-  test('should report unknown component node references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  name: 'unknown',
-                  type: 'component',
-                  attrs: {},
-                  events: {},
-                  children: ['test'],
-                  style: {},
-                },
-                test: {
-                  name: 'unknown-package',
-                  package: 'unknown',
-                  type: 'component',
-                  attrs: {},
-                  events: {},
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [unknownComponentRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('unknown component')
-    expect(problems[0].details).toEqual({ name: 'unknown' })
-    expect(problems[1].code).toBe('unknown component')
-    expect(problems[1].details).toEqual({ name: 'unknown-package' })
-  })
-
-  test('should not report known component node references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          packages: {
-            known_package: {
-              manifest: {
-                commit: '123',
-                name: 'known_package',
-              },
-              components: {
-                known_package_component: {
-                  name: 'known_package_component',
-                  nodes: {},
-                  formulas: {},
-                  apis: {},
-                  attributes: {},
-                  variables: {},
-                },
-              },
-            },
-          },
-          components: {
-            known: {
-              name: 'known',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  name: 'known',
-                  type: 'component',
-                  attrs: {},
-                  events: {},
-                  children: ['test'],
-                  style: {},
-                },
-                test: {
-                  name: 'known_package_component',
-                  package: 'known_package',
-                  type: 'component',
-                  attrs: {},
-                  events: {},
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [unknownComponentRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-})

package/src/rules/components/unknownComponentRule.ts

@@ -1,24 +0,0 @@
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Rule } from '../../types'
-
-export const unknownComponentRule: Rule<{
-  name: string
-}> = {
-  code: 'unknown component',
-  level: 'error',
-  category: 'Unknown Reference',
-  visit: (report, { path, files, value, nodeType }) => {
-    if (
-      nodeType !== 'component-node' ||
-      value.type !== 'component' ||
-      // Check if the component exists in the project
-      (!isDefined(value.package) && isDefined(files.components[value.name])) ||
-      // Check if the component exists in a specified package
-      (value.package &&
-        isDefined(files.packages?.[value.package]?.components[value.name]))
-    ) {
-      return
-    }
-    report(path, { name: value.name })
-  },
-}