@nordcraft/search 1.0.53 → 1.0.55

package/src/rules/context/unknownContextProviderRule.ts

@@ -1,30 +0,0 @@
-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

@@ -1,120 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-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

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

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

@@ -1,125 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { createRequiredDirectParentRule } from './createRequiredDirectParentRule'
-
-describe('createRequiredDirectParentRule', () => {
-  test('should detect wrong direct parent', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {},
-                  tag: 'div',
-                  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: [
-          createRequiredDirectParentRule(
-            ['ul', 'ol'],
-            ['li', 'script', 'template'],
-          ),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('required direct parent')
-    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'child1'])
-    expect(problems[0].details).toEqual({
-      parentTag: 'div',
-      childTag: 'li',
-      allowedParentTags: ['ul', 'ol'],
-    })
-    expect(problems[1].code).toBe('required direct parent')
-    expect(problems[1].path).toEqual(['components', 'test', 'nodes', 'child2'])
-    expect(problems[1].details).toEqual({
-      parentTag: 'div',
-      childTag: 'li',
-      allowedParentTags: ['ul', 'ol'],
-    })
-  })
-  test('should not detect valid direct parent', () => {
-    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: [createRequiredDirectParentRule(['ul'], ['li'])],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/dom/createRequiredDirectParentRule.ts

@@ -1,41 +0,0 @@
-import type { Level, Rule } from '../../types'
-
-export function createRequiredDirectParentRule(
-  parentTags: string[],
-  childTags: string[],
-  level: Level = 'warning',
-): Rule<{
-  parentTag: string
-  childTag: string
-  allowedParentTags: string[]
-}> {
-  return {
-    code: 'required direct parent',
-    level,
-    category: 'Accessibility',
-    visit: (report, args) => {
-      if (args.nodeType !== 'component-node') {
-        return
-      }
-      const { value, component, path } = args
-      if (value.type !== 'element' || !childTags.includes(value.tag)) {
-        return
-      }
-      const nodeId = String(args.path[args.path.length - 1])
-      const parent = Object.values(component.nodes).find(
-        (node) => node.type === 'element' && node.children.includes(nodeId),
-      )
-      if (
-        parent &&
-        parent.type === 'element' &&
-        !parentTags.includes(parent.tag)
-      ) {
-        report(path, {
-          parentTag: parent.tag,
-          childTag: value.tag,
-          allowedParentTags: parentTags,
-        })
-      }
-    },
-  }
-}

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

@@ -1,160 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { createRequiredElementAttributeRule } from './createRequiredElementAttributeRule'
-
-describe('requiredElementAttributeRule', () => {
-  test('should detect missing required element attribute', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {},
-                  classes: {},
-                  events: {},
-                  tag: 'img',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [
-          createRequiredElementAttributeRule({
-            tag: 'img',
-            attribute: 'alt',
-            allowEmptyString: true,
-          }),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('required element attribute')
-    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'root'])
-  })
-  test('should detect empty required element attribute', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {
-                    alt: { type: 'value', value: '' },
-                  },
-                  classes: {},
-                  events: {},
-                  tag: 'img',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [
-          createRequiredElementAttributeRule({ tag: 'img', attribute: 'src' }),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('required element attribute')
-    expect(problems[0].path).toEqual(['components', 'test', 'nodes', 'root'])
-  })
-  test('should not detect issues when elements can have empty attributes', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {
-                    alt: { type: 'value', value: '' },
-                  },
-                  classes: {},
-                  events: {},
-                  tag: 'img',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [
-          createRequiredElementAttributeRule({
-            tag: 'img',
-            attribute: 'alt',
-            allowEmptyString: true,
-          }),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-  test('should not detect issues when elements have all required attributes', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            test: {
-              name: 'test',
-              nodes: {
-                root: {
-                  type: 'element',
-                  attrs: {
-                    alt: { type: 'value', value: 'test' },
-                  },
-                  classes: {},
-                  events: {},
-                  tag: 'img',
-                  children: [],
-                  style: {},
-                },
-              },
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-            },
-          },
-        },
-        rules: [
-          createRequiredElementAttributeRule({ tag: 'img', attribute: 'alt' }),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(0)
-  })
-})

package/src/rules/dom/createRequiredElementAttributeRule.ts

@@ -1,44 +0,0 @@
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { Level, Rule } from '../../types'
-
-export function createRequiredElementAttributeRule({
-  tag,
-  attribute,
-  level = 'warning',
-  allowEmptyString = false,
-}: {
-  tag: string
-  attribute: string
-  level?: Level
-  allowEmptyString?: boolean
-}): Rule<{
-  tag: string
-  attribute: string
-}> {
-  return {
-    code: 'required element attribute',
-    level: level,
-    category: 'Accessibility',
-    visit: (report, { path, nodeType, value }) => {
-      if (
-        nodeType === 'component-node' &&
-        value.type === 'element' &&
-        value.tag === tag
-      ) {
-        const attributeValue = value.attrs[attribute]
-        // Report the missing attribute if it is not defined or statically empty/nullish
-        if (!isDefined(attributeValue)) {
-          return report(path, { tag, attribute })
-        }
-        if (attributeValue.type === 'value') {
-          if (!isDefined(attributeValue.value)) {
-            return report(path, { tag, attribute })
-          }
-          if (!allowEmptyString && attributeValue.value === '') {
-            return report(path, { tag, attribute })
-          }
-        }
-      }
-    },
-  }
-}

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

@@ -1,77 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { createRequiredMetaTagRule } from './createRequiredMetaTagRule'
-
-describe('createRequiredMetaTagRule', () => {
-  test('should detect missing required meta tag', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            'test-page': {
-              name: 'test-page',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {
-                  title: { formula: { type: 'value', value: null } },
-                },
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [
-          createRequiredMetaTagRule('title'),
-          createRequiredMetaTagRule('description'),
-        ],
-      }),
-    )
-
-    expect(problems).toHaveLength(2)
-    expect(problems[0].code).toBe('required meta tag')
-    expect(problems[0].details.tag).toEqual('title')
-    expect(problems[1].code).toBe('required meta tag')
-    expect(problems[1].details.tag).toEqual('description')
-  })
-  test('should not detect meta tags with required meta tag', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          formulas: {},
-          components: {
-            'test-page': {
-              name: 'test-page',
-              nodes: {},
-              formulas: {},
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {
-                  title: { formula: { type: 'value', value: 'some value' } },
-                  description: {
-                    formula: { type: 'and', arguments: [] },
-                  },
-                },
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [
-          createRequiredMetaTagRule('title'),
-          createRequiredMetaTagRule('description'),
-        ],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-})

package/src/rules/dom/createRequiredMetaTagRule.ts

@@ -1,33 +0,0 @@
-import { isFormula } from '@nordcraft/core/dist/formula/formula'
-import type { Level, Rule } from '../../types'
-
-export function createRequiredMetaTagRule(
-  tag: string,
-  level: Level = 'warning',
-): Rule<{
-  tag: string
-}> {
-  return {
-    code: 'required meta tag',
-    level: level,
-    category: 'SEO',
-    visit: (report, { path, nodeType, value }) => {
-      if (!(nodeType === 'component' && value.route)) {
-        return
-      }
-
-      const tagValue = value.route.info?.[tag as keyof typeof value.route.info]
-      const formula = isFormula(tagValue?.formula)
-        ? tagValue.formula
-        : undefined
-
-      if (
-        !tagValue ||
-        !formula ||
-        (formula.type === 'value' && !formula.value)
-      ) {
-        report(path, { tag: tag })
-      }
-    },
-  }
-}