@nordcraft/search 1.0.43 → 1.0.45

package/src/rules/formulas/noReferenceComponentFormulaRule.ts

@@ -1,5 +1,6 @@
 import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
 import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceComponentFormulaRule: Rule<{
   name: string
@@ -38,7 +39,7 @@ export const noReferenceComponentFormulaRule: Rule<{
     }
 
     // It is possible that a formula is never used, but still has subscribers
-    const contextSubscribers = []
+    const contextSubscribers: string[] = []
     if (value.exposeInContext) {
       for (const _component of Object.values(files.components)) {
         // Enforce that the component is not undefined since we're iterating
@@ -74,7 +75,18 @@ export const noReferenceComponentFormulaRule: Rule<{
         }
       }
     }
-
-    report(path, { contextSubscribers, name: value.name })
+    report(
+      args.path,
+      {
+        contextSubscribers,
+        name: value.name,
+      },
+      ['delete-component-formula'],
+    )
+  },
+  fixes: {
+    'delete-component-formula': removeFromPathFix,
   },
 }
+
+export type NoReferenceComponentFormulaRuleFix = 'delete-component-formula'

package/src/rules/formulas/noReferenceProjectFormulaRule.ts

@@ -1,106 +1,99 @@
 import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
 import type { Formula } from '@nordcraft/core/dist/formula/formula'
 import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
-import { omit } from '@nordcraft/core/dist/utils/collections'
 import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
 import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
-import type { NodeType, Rule } from '../../types'
+import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceProjectFormulaRule: Rule<void> = {
   code: 'no-reference project formula',
   level: 'warning',
   category: 'No References',
-  visit: (report, details) => {
-    if (!hasReferences(details)) {
-      report(details.path, undefined, ['delete-project-formula'])
+  visit: (report, { value, path, files, nodeType, memo }) => {
+    if (nodeType !== 'project-formula' || value.exported === true) {
+      return
     }
-  },
-  fixes: {
-    'delete-project-formula': (data) => {
-      if (!hasReferences(data)) {
-        return omit(data.files, data.path)
-      }
-    },
-  },
-}
-
-export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
-
-const hasReferences = ({ value, files, nodeType, memo }: NodeType) => {
-  if (nodeType !== 'project-formula' || value.exported === true) {
-    return true
-  }
 
-  // Check in all API services first, since that should be quick
-  for (const apiService of Object.values(files.services ?? {})) {
-    const service = new ToddleApiService({
-      service: apiService,
-      globalFormulas: { formulas: files.formulas, packages: files.packages },
-    })
-    const formulas = service.formulasInService()
-    for (const { path: _formulaPath, formula } of formulas) {
-      // Check if the formula is used in the formula
-      if (checkFormula(formula, value.name)) {
-        return true
+    // Check in all API services first, since that should be quick
+    for (const apiService of Object.values(files.services ?? {})) {
+      const service = new ToddleApiService({
+        service: apiService,
+        globalFormulas: { formulas: files.formulas, packages: files.packages },
+      })
+      const formulas = service.formulasInService()
+      for (const { path: _formulaPath, formula } of formulas) {
+        // Check if the formula is used in the formula
+        if (checkFormula(formula, value.name)) {
+          return
+        }
       }
     }
-  }
 
-  // Check routes before components, since they should be quicker
-  for (const projectRoute of Object.values(files.routes ?? {})) {
-    const route = new ToddleRoute({
-      route: projectRoute,
-      globalFormulas: { formulas: files.formulas, packages: files.packages },
-    })
-    const formulas = route.formulasInRoute()
-    for (const { path: _formulaPath, formula } of formulas) {
-      // Check if the formula is used in the formula
-      if (checkFormula(formula, value.name)) {
-        return true
-      }
-    }
-  }
-
-  const componentFormulaReferences = memo('componentFormulaReferences', () => {
-    const usedFormulas = new Set<string>()
-    for (const component of Object.values(files.components)) {
-      const c = new ToddleComponent({
-        // Enforce that the component is not undefined since we're iterating
-        component: component!,
-        getComponent: (name) => files.components[name],
-        packageName: undefined,
-        globalFormulas: {
-          formulas: files.formulas,
-          packages: files.packages,
-        },
+    // Check routes before components, since they should be quicker
+    for (const projectRoute of Object.values(files.routes ?? {})) {
+      const route = new ToddleRoute({
+        route: projectRoute,
+        globalFormulas: { formulas: files.formulas, packages: files.packages },
       })
-      for (const { formula } of c.formulasInComponent()) {
-        if (formula.type === 'function') {
-          usedFormulas.add(formula.name)
+      const formulas = route.formulasInRoute()
+      for (const { path: _formulaPath, formula } of formulas) {
+        // Check if the formula is used in the formula
+        if (checkFormula(formula, value.name)) {
+          return
         }
       }
     }
-    return usedFormulas
-  })
 
-  if (componentFormulaReferences.has(value.name)) {
-    return true
-  }
+    const componentFormulaReferences = memo(
+      'componentFormulaReferences',
+      () => {
+        const usedFormulas = new Set<string>()
+        for (const component of Object.values(files.components)) {
+          const c = new ToddleComponent({
+            // Enforce that the component is not undefined since we're iterating
+            component: component!,
+            getComponent: (name) => files.components[name],
+            packageName: undefined,
+            globalFormulas: {
+              formulas: files.formulas,
+              packages: files.packages,
+            },
+          })
+          for (const { formula } of c.formulasInComponent()) {
+            if (formula.type === 'function') {
+              usedFormulas.add(formula.name)
+            }
+          }
+        }
+        return usedFormulas
+      },
+    )
 
-  // TODO: Memoize similar to above. We need have a helper class `ToddleFormula` with `ToddleFormula.normalizeFormulas()`
-  for (const f of Object.values(files.formulas ?? {})) {
-    if (f.name === value.name) {
-      continue
+    if (componentFormulaReferences.has(value.name)) {
+      return
     }
 
-    // Check if the formula is used in the formula
-    if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
-      return true
+    // TODO: Memoize similar to above. We need have a helper class `ToddleFormula` with `ToddleFormula.normalizeFormulas()`
+    for (const f of Object.values(files.formulas ?? {})) {
+      if (f.name === value.name) {
+        continue
+      }
+
+      // Check if the formula is used in the formula
+      if (isToddleFormula(f) && checkFormula(f.formula, value.name)) {
+        return
+      }
     }
-  }
-  return false
+    report(path, undefined, ['delete-project-formula'])
+  },
+  fixes: {
+    'delete-project-formula': removeFromPathFix,
+  },
 }
 
+export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
+
 const checkArguments = (
   args: {
     formula: Formula

package/src/rules/noReferenceNodeRule.test.ts

@@ -0,0 +1,140 @@
+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 { noReferenceNodeRule } from './noReferenceNodeRule'
+
+describe('find noReferenceNodeRule', () => {
+  test('should detect nodes with no references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  id: 'root',
+                  type: 'element',
+                  tag: 'div',
+                  children: [],
+                  attrs: {},
+                  style: {},
+                  events: {},
+                  classes: {},
+                },
+                '1LisbD0eCjsuccoUwajn1': {
+                  id: 'XdhwPGsdFNI4s8A0oMwre',
+                  type: 'text',
+                  value: { type: 'value', value: 'Clone the project' },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceNodeRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].details).toEqual({ node: '1LisbD0eCjsuccoUwajn1' })
+    expect(problems[0].path).toEqual([
+      'components',
+      'test',
+      'nodes',
+      '1LisbD0eCjsuccoUwajn1',
+    ])
+  })
+
+  test('should not detect nodes with references', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            test: {
+              name: 'test',
+              nodes: {
+                root: {
+                  id: 'root',
+                  type: 'element',
+                  tag: 'div',
+                  children: ['1LisbD0eCjsuccoUwajn1'],
+                  attrs: {},
+                  style: {},
+                  events: {},
+                  classes: {},
+                },
+                '1LisbD0eCjsuccoUwajn1': {
+                  id: 'XdhwPGsdFNI4s8A0oMwre',
+                  type: 'text',
+                  value: { type: 'value', value: 'Clone the project' },
+                },
+              },
+              formulas: {},
+              apis: {},
+              attributes: {},
+              variables: {},
+            },
+          },
+        },
+        rules: [noReferenceNodeRule],
+      }),
+    )
+
+    expect(problems).toEqual([])
+  })
+})
+
+describe('fix noReferenceNodeRule', () => {
+  test('should delete nodes with no references', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              id: 'root',
+              type: 'element',
+              tag: 'div',
+              children: ['used'],
+              attrs: {},
+              style: {},
+              events: {},
+              classes: {},
+            },
+            '1LisbD0eCjsuccoUwajn1': {
+              id: 'XdhwPGsdFNI4s8A0oMwre',
+              type: 'text',
+              value: { type: 'value', value: 'Clone the project' },
+            },
+            used: {
+              id: 'used',
+              type: 'text',
+              value: { type: 'value', value: 'I am used' },
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: noReferenceNodeRule,
+      fixType: 'delete orphan node',
+    })
+    expect(Object.keys(fixedFiles.components.test!.nodes)).toEqual([
+      'root',
+      'used',
+    ])
+  })
+})

package/src/rules/noReferenceNodeRule.ts

@@ -0,0 +1,27 @@
+import type { Rule } from '../types'
+import { removeFromPathFix } from '../util/removeUnused.fix'
+
+export const noReferenceNodeRule: Rule<{ node: string }> = {
+  code: 'no-reference node',
+  level: 'warning',
+  category: 'No References',
+  visit: (report, args) => {
+    if (args.nodeType !== 'component') {
+      return
+    }
+    const { path, value: component } = args
+    const referencedNodes = new Set(
+      Object.values(component.nodes).flatMap((node) => node.children ?? []),
+    )
+    for (const key of Object.keys(component.nodes)) {
+      if (key !== 'root' && !referencedNodes.has(key)) {
+        report([...path, 'nodes', key], { node: key }, ['delete orphan node'])
+      }
+    }
+  },
+  fixes: {
+    'delete orphan node': removeFromPathFix,
+  },
+}
+
+export type NoReferenceNodeRuleFix = 'delete orphan node'

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

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

@@ -0,0 +1,35 @@
+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/searchProject.ts

@@ -200,6 +200,7 @@ function visitNode(args: {
     useExactPaths: boolean
   } & NodeType
   state: ApplicationState | undefined
+  fixOptions: never
 }): Generator<Result>
 function visitNode(args: {
   args: {
@@ -210,7 +211,7 @@ function visitNode(args: {
     useExactPaths: boolean
   } & NodeType
   state: ApplicationState | undefined
-  fixOptions: { mode: 'FIX'; fixType: FixType }
+  fixOptions: FixOptions
 }): Generator<ProjectFiles | void>
 function* visitNode({
   args,
@@ -225,7 +226,7 @@ function* visitNode({
     useExactPaths: boolean
   } & NodeType
   state: ApplicationState | undefined
-  fixOptions?: { mode: 'FIX'; fixType: FixType }
+  fixOptions?: FixOptions
 }): Generator<Result | ProjectFiles | void> {
   const { rules, pathsToVisit, useExactPaths, ...data } = args
   const { files, value, path, memo, nodeType } = data
@@ -243,22 +244,36 @@ function* visitNode({
     !useExactPaths ||
     shouldSearchExactPath({ path: data.path, pathsToVisit })
   ) {
-    if (fixOptions) {
-      // We're fixing issues
-      for (const rule of rules) {
-        const fixedFiles = rule.fixes?.[fixOptions.fixType]?.(data, state)
-        if (fixedFiles) {
-          yield fixedFiles
-        }
-      }
-    } else {
-      // We're looking for issues
-      const results: Result[] = []
-      for (const rule of rules) {
-        // eslint-disable-next-line no-console
-        console.timeStamp(`Visiting rule ${rule.code}`)
-        rule.visit(
-          (path, details, fixes) => {
+    const results: Result[] = []
+    let fixedFiles: ProjectFiles | undefined
+    for (const rule of rules) {
+      // eslint-disable-next-line no-console
+      console.timeStamp(`Visiting rule ${rule.code}`)
+      rule.visit(
+        // Report callback used to report issues
+        (path, details, fixes) => {
+          if (fixOptions) {
+            // We're in "fix mode"
+            if (
+              // We only overwrite fixedFiles once to avoid conflicting fixes
+              !fixedFiles &&
+              // The current fix must be one of the fixes reported
+              fixes?.includes(fixOptions.fixType) &&
+              // The rule must have an implementation for the fix
+              rule.fixes?.[fixOptions.fixType]
+            ) {
+              const ruleFixes = rule.fixes[fixOptions.fixType]?.(
+                // We must use the path from the report, not the original path
+                // because the report might be for a subpath
+                { ...data, path },
+                state,
+              )
+              if (ruleFixes) {
+                fixedFiles = ruleFixes
+              }
+            }
+          } else {
+            // We're in "report mode"
             results.push({
               code: rule.code,
               category: rule.category,
@@ -267,12 +282,22 @@ function* visitNode({
               details,
               fixes,
             })
-          },
-          data,
-          state,
-        )
+          }
+        },
+        data,
+        state,
+      )
+      if (fixedFiles) {
+        // We have applied a fix, stop processing more rules
+        break
       }
+    }
 
+    if (fixOptions) {
+      if (fixedFiles) {
+        yield fixedFiles
+      }
+    } else {
       for (const result of results) {
         yield result
       }
@@ -551,6 +576,25 @@ function* visitNode({
             })
           }
         }
+        for (const [styleKey, styleValue] of Object.entries(
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          value.style ?? {},
+        )) {
+          yield* visitNode({
+            args: {
+              nodeType: 'style-declaration',
+              value: { styleProperty: styleKey, styleValue, element: value },
+              path: [...path, 'style', styleKey],
+              rules,
+              files,
+              pathsToVisit,
+              useExactPaths,
+              memo,
+            },
+            state,
+            fixOptions: fixOptions as any,
+          })
+        }
       }
       break