@nordcraft/search 1.0.43 → 1.0.44

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/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,31 @@ 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]?.(data, state)
+              if (ruleFixes) {
+                fixedFiles = ruleFixes
+              }
+            }
+          } else {
+            // We're in "report mode"
             results.push({
               code: rule.code,
               category: rule.category,
@@ -267,12 +277,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
       }

package/src/types.d.ts

@@ -23,8 +23,12 @@ import type {
 } from '@nordcraft/ssr/dist/ssr.types'
 import type { LegacyActionRuleFix } from './rules/actions/legacyActionRule'
 import type { NoReferenceProjectActionRuleFix } from './rules/actions/noReferenceProjectActionRule'
+import type { NoReferenceApiRuleFix } from './rules/apis/noReferenceApiRule'
+import type { NoReferenceAttributeRuleFix } from './rules/attributes/noReferenceAttributeRule'
 import type { NoReferenceComponentRuleFix } from './rules/components/noReferenceComponentRule'
+import type { NoReferenceEventRuleFix } from './rules/events/noReferenceEventRule'
 import type { LegacyFormulaRuleFix } from './rules/formulas/legacyFormulaRule'
+import type { NoReferenceComponentFormulaRuleFix } from './rules/formulas/noReferenceComponentFormulaRule'
 import type { NoReferenceProjectFormulaRuleFix } from './rules/formulas/noReferenceProjectFormulaRule'
 
 type Code =
@@ -251,9 +255,9 @@ type FormulaNode<F = Formula> = {
   component?: ToddleComponent<Function>
 } & Base
 
-type ActionModelNode = {
+type ActionModelNode<A = ActionModel> = {
   nodeType: 'action-model'
-  value: ActionModel
+  value: A
   component: ToddleComponent<Function>
 } & Base
 
@@ -320,6 +324,10 @@ type FixType =
   | NoReferenceComponentRuleFix
   | NoReferenceProjectFormulaRuleFix
   | NoReferenceProjectActionRuleFix
+  | NoReferenceApiRuleFix
+  | NoReferenceAttributeRuleFix
+  | NoReferenceEventRuleFix
+  | NoReferenceComponentFormulaRuleFix
 
 export interface Rule<T = unknown, V = NodeType> {
   category: Category
@@ -330,10 +338,10 @@ export interface Rule<T = unknown, V = NodeType> {
     data: V,
     state?: ApplicationState | undefined,
   ) => void
-  fixes?: Partial<
-    Record<
-      FixType,
-      (data: V, state?: ApplicationState | undefined) => ProjectFiles | void
-    >
-  >
+  fixes?: Partial<Record<FixType, FixFunction>>
 }
+
+export type FixFunction<T extends NodeType> = (
+  data: T,
+  state?: ApplicationState,
+) => ProjectFiles | void

package/src/util/removeUnused.fix.ts

@@ -0,0 +1,5 @@
+import { omit } from '@nordcraft/core/dist/utils/collections'
+import type { FixFunction, NodeType } from '../types'
+
+export const removeFromPathFix: FixFunction<NodeType> = ({ path, files }) =>
+  omit(files, path)