@nordcraft/search 1.0.88 → 1.0.90

package/src/rules/issues/formulas/noReferenceProjectFormulaRule.test.ts

@@ -290,6 +290,39 @@ describe('find noReferenceFormulaRule', () => {
 
     expect(problems).toBeEmpty()
   })
+
+  test('should report if formula is only used by itself', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {
+            'self-referencing-formula': {
+              name: 'self-referencing-formula',
+              arguments: [],
+              formula: {
+                type: 'and',
+                arguments: [
+                  {
+                    formula: {
+                      type: 'function',
+                      name: 'self-referencing-formula',
+                      arguments: [],
+                    },
+                  },
+                ],
+              },
+            },
+          },
+          components: {},
+        },
+        rules: [noReferenceProjectFormulaRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project formula')
+    expect(problems[0].path).toEqual(['formulas', 'self-referencing-formula'])
+  })
 })
 
 describe('fix noReferenceFormulaRule', () => {

package/src/rules/issues/formulas/noReferenceProjectFormulaRule.ts

@@ -1,10 +1,6 @@
-import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
-import type { Formula } from '@nordcraft/core/dist/formula/formula'
-import { isToddleFormula } from '@nordcraft/core/dist/formula/formula'
-import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
-import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
 import type { Rule } from '../../../types'
 import { removeFromPathFix } from '../../../util/removeUnused.fix'
+import { projectFormulaIsReferenced } from './projectFormulaIsReferenced.memo'
 
 export const noReferenceProjectFormulaRule: Rule<void> = {
   code: 'no-reference project formula',
@@ -15,76 +11,10 @@ export const noReferenceProjectFormulaRule: Rule<void> = {
       return
     }
 
-    // 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
-        }
-      }
-    }
-
-    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
-      },
-    )
-
-    if (componentFormulaReferences.has(value.name)) {
+    if (projectFormulaIsReferenced(files, memo)(value.name)) {
       return
     }
 
-    // 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
-      }
-    }
     report({
       path,
       info: {
@@ -100,33 +30,3 @@ export const noReferenceProjectFormulaRule: Rule<void> = {
 }
 
 export type NoReferenceProjectFormulaRuleFix = 'delete-project-formula'
-
-const checkArguments = (
-  args: {
-    formula: Formula
-  }[],
-  formulaName: string,
-) => {
-  args.forEach((a) => {
-    if (checkFormula(a.formula, formulaName)) {
-      return true
-    }
-  })
-  return false
-}
-
-const checkFormula = (formula: Formula, formulaName: string) => {
-  if (formula.type === 'function' && formula.name === formulaName) {
-    return true
-  }
-  if (
-    formula.type === 'object' ||
-    formula.type === 'array' ||
-    formula.type === 'or' ||
-    formula.type === 'and' ||
-    formula.type === 'apply'
-  ) {
-    checkArguments(formula.arguments ?? [], formulaName)
-  }
-  return false
-}

package/src/rules/issues/formulas/projectFormulaIsReferenced.memo.ts

@@ -0,0 +1,112 @@
+import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
+import {
+  isToddleFormula,
+  type Formula,
+} from '@nordcraft/core/dist/formula/formula'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
+import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
+import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
+import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
+import type { MemoFn } from '../../../types'
+
+export const projectFormulaIsReferenced = (
+  files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>,
+  memo: MemoFn,
+) => {
+  const allUsedFormulaKeys = memo('all-used-formulas', () => {
+    const usedFormulas = new Set<string>()
+
+    // 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
+        checkFormula(usedFormulas, formula)
+      }
+    }
+
+    // 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
+        checkFormula(usedFormulas, formula)
+      }
+    }
+
+    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.package, formula.name].filter(isDefined).join('/'),
+          )
+        }
+      }
+    }
+
+    for (const f of Object.values(files.formulas ?? {})) {
+      // Check if the formula is used in the formula
+      if (isToddleFormula(f)) {
+        const usedFormulasMinusSelf = new Set<string>()
+        checkFormula(usedFormulasMinusSelf, f.formula)
+        // Add all minus self (a formula is unused, if it's only used by itself)
+        usedFormulasMinusSelf.delete(f.name)
+        usedFormulasMinusSelf.forEach((f) => usedFormulas.add(f))
+      }
+    }
+
+    return usedFormulas
+  })
+
+  return (formulaName: string, packageName?: string) => {
+    return allUsedFormulaKeys.has(
+      [packageName, formulaName].filter(isDefined).join('/'),
+    )
+  }
+}
+
+const checkArguments = (
+  usedFormulas: Set<string>,
+  args: {
+    formula: Formula
+  }[],
+) => {
+  args.forEach((a) => {
+    checkFormula(usedFormulas, a.formula)
+  })
+}
+
+const checkFormula = (usedFormulas: Set<string>, formula: Formula) => {
+  if (formula.type === 'function') {
+    usedFormulas.add(
+      [formula.package, formula.name].filter(isDefined).join('/'),
+    )
+    checkArguments(usedFormulas, formula.arguments ?? [])
+  } else if (
+    formula.type === 'object' ||
+    formula.type === 'array' ||
+    formula.type === 'or' ||
+    formula.type === 'and' ||
+    formula.type === 'apply'
+  ) {
+    checkArguments(usedFormulas, formula.arguments ?? [])
+  }
+}

package/src/rules/issues/miscellaneous/createStaticSizeConstraintRule.ts

@@ -1,6 +1,6 @@
 import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import { VOID_HTML_ELEMENTS } from '@nordcraft/core/dist/utils/html'
 import { isDefined } from '@nordcraft/core/dist/utils/util'
-import { VOID_HTML_ELEMENTS } from '@nordcraft/ssr/dist/const'
 import type { Level, Rule } from '../../../types'
 
 export function createStaticSizeConstraintRule(

package/src/rules/issues/miscellaneous/miscRules.index.ts

@@ -1,5 +1,6 @@
 import { createStaticSizeConstraintRule } from './createStaticSizeConstraintRule'
 import { noReferenceNodeRule } from './noReferenceNodeRule'
+import { noReferenceProjectPackageRule } from './noReferencePackageRule'
 import { requireExtensionRule } from './requireExtensionRule'
 import { unknownCookieRule } from './unknownCookieRule'
 
@@ -11,4 +12,5 @@ export default [
   createStaticSizeConstraintRule('svg', 100 * 1024),
   // 50 KB is a large img element (with potential base64 encoded image)
   createStaticSizeConstraintRule('img', 50 * 1024),
+  noReferenceProjectPackageRule,
 ]

package/src/rules/issues/miscellaneous/noReferencePackageRule.test.ts

@@ -0,0 +1,289 @@
+import type { ProjectFiles } from '@nordcraft/ssr/src/ssr.types'
+import { describe, expect, test } from 'bun:test'
+import { fixProject } from '../../../fixProject'
+import { searchProject } from '../../../searchProject'
+import { noReferenceProjectPackageRule } from './noReferencePackageRule'
+
+describe('noReferenceProjectPackageRule', () => {
+  test('should report when no formula, actions or components from a package is used', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {},
+          packages: {
+            'my-pkg': {
+              manifest: { name: 'my-pkg', commit: 'abc' },
+              formulas: {
+                f1: {
+                  name: 'f1',
+                  exported: true,
+                  arguments: [],
+                  formula: { type: 'value', value: 1 },
+                },
+              },
+              actions: {
+                a1: {
+                  name: 'a1',
+                  version: 2,
+                  exported: true,
+                  handler: () => {},
+                  variableArguments: false,
+                },
+              },
+              components: {
+                c1: {
+                  name: 'c1',
+                  exported: true,
+                  nodes: {
+                    root: {
+                      type: 'element',
+                      tag: 'div',
+                      children: [],
+                      attrs: {},
+                      style: {},
+                      events: {},
+                      classes: {},
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].path).toEqual(['packages', 'my-pkg'])
+  })
+
+  test('should not report if just one formula is used', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            comp: {
+              name: 'comp',
+              nodes: {
+                root: {
+                  type: 'element',
+                  tag: 'div',
+                  children: [],
+                  attrs: {},
+                  style: {},
+                  events: {
+                    onClick: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'SetVariable',
+                          variable: 'v1',
+                          data: {
+                            type: 'function',
+                            name: 'f1',
+                            package: 'my-pkg',
+                            arguments: [],
+                          },
+                        },
+                      ],
+                    },
+                  },
+                  classes: {},
+                },
+              },
+            },
+          },
+          packages: {
+            'my-pkg': {
+              manifest: { name: 'my-pkg', commit: 'abc' },
+              formulas: {
+                f1: {
+                  name: 'f1',
+                  exported: true,
+                  arguments: [],
+                  formula: { type: 'value', value: 1 },
+                },
+              },
+              actions: {},
+              components: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toBeEmpty()
+  })
+
+  test('should not report if just one action is used', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            comp: {
+              name: 'comp',
+              nodes: {
+                root: {
+                  type: 'element',
+                  tag: 'button',
+                  children: [],
+                  attrs: {},
+                  style: {},
+                  events: {
+                    click: {
+                      trigger: 'click',
+                      actions: [
+                        {
+                          type: 'Custom',
+                          name: 'a1',
+                          package: 'my-pkg',
+                          arguments: [],
+                        },
+                      ],
+                    },
+                  },
+                  classes: {},
+                },
+              },
+            },
+          },
+          packages: {
+            'my-pkg': {
+              manifest: { name: 'my-pkg', commit: 'abc' },
+              formulas: {},
+              actions: {
+                a1: {
+                  name: 'a1',
+                  version: 2,
+                  exported: true,
+                  handler: () => {},
+                  variableArguments: false,
+                },
+              },
+              components: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+
+  test('should not report if just one component is used', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {
+            main: {
+              name: 'main',
+              nodes: {
+                root: {
+                  type: 'component',
+                  name: 'c1',
+                  package: 'my-pkg',
+                  attrs: {},
+                  children: [],
+                  events: {},
+                },
+              },
+            },
+          },
+          packages: {
+            'my-pkg': {
+              manifest: { name: 'my-pkg', commit: 'abc' },
+              formulas: {},
+              actions: {},
+              components: {
+                c1: {
+                  name: 'c1',
+                  exported: true,
+                  nodes: {
+                    root: {
+                      type: 'element',
+                      tag: 'div',
+                      children: [],
+                      attrs: {},
+                      style: {},
+                      events: {},
+                      classes: {},
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(0)
+  })
+
+  test('should report when a package has no components, actions or formulas', () => {
+    const problems = Array.from(
+      searchProject({
+        files: {
+          formulas: {},
+          components: {},
+          packages: {
+            'empty-pkg': {
+              manifest: { name: 'empty-pkg', commit: 'abc' },
+              formulas: {},
+              actions: {},
+              components: {},
+            },
+          },
+        },
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].path).toEqual(['packages', 'empty-pkg'])
+  })
+})
+
+describe('fix noReferenceProjectPackageRule', () => {
+  test('should remove unreferenced package', () => {
+    const project: ProjectFiles = {
+      formulas: {},
+      components: {},
+      packages: {
+        'my-pkg': {
+          manifest: { name: 'my-pkg', commit: 'abc' },
+          formulas: {},
+          actions: {},
+          components: {},
+        },
+      },
+    }
+
+    const problems = Array.from(
+      searchProject({
+        files: project,
+        rules: [noReferenceProjectPackageRule],
+      }),
+    )
+
+    expect(problems).toHaveLength(1)
+    expect(problems[0].code).toBe('no-reference project package')
+    expect(problems[0].fixes).toEqual(['uninstall-package'])
+
+    const fixedProject = fixProject({
+      files: project,
+      rule: noReferenceProjectPackageRule,
+      fixType: 'uninstall-package',
+    })
+
+    expect(fixedProject.packages).toEqual({})
+  })
+})

package/src/rules/issues/miscellaneous/noReferencePackageRule.ts

@@ -0,0 +1,72 @@
+import type { PluginActionV2 } from '@nordcraft/core/dist/types'
+import type { Rule } from '../../../types'
+import { removeFromPathFix } from '../../../util/removeUnused.fix'
+import { projectActionIsReferenced } from '../actions/projectActionIsReferenced.memo'
+import { componentIsReferenced } from '../components/componentIsReferenced.memo'
+import { projectFormulaIsReferenced } from '../formulas/projectFormulaIsReferenced.memo'
+
+export const noReferenceProjectPackageRule: Rule<{ node: string }> = {
+  code: 'no-reference project package',
+  level: 'info',
+  category: 'No References',
+  visit: (report, info) => {
+    if (info.nodeType !== 'project-package') {
+      return
+    }
+
+    const { files, memo, path, value, packageName } = info
+
+    const exportedFormulas = Object.entries(value.formulas ?? {}).filter(
+      ([, formula]) => formula.exported,
+    )
+    if (exportedFormulas.length > 0) {
+      const projectFormulaIsReferencedFn = projectFormulaIsReferenced(
+        files,
+        memo,
+      )
+      for (const [, formula] of exportedFormulas) {
+        if (projectFormulaIsReferencedFn(formula.name, packageName)) {
+          return
+        }
+      }
+    }
+
+    const exportedActions = Object.entries(value.actions ?? {}).filter(
+      ([, action]) => (action as PluginActionV2).exported,
+    )
+    if (exportedActions.length > 0) {
+      const projectActionIsReferencedFn = projectActionIsReferenced(files, memo)
+      for (const [, action] of exportedActions) {
+        if (projectActionIsReferencedFn(action.name, packageName)) {
+          return
+        }
+      }
+    }
+
+    const exportedComponents = Object.entries(value.components ?? {}).filter(
+      ([, component]) => component?.exported,
+    )
+    if (exportedComponents.length > 0) {
+      const componentIsReferencedFn = componentIsReferenced(files, memo)
+      for (const [, component] of exportedComponents) {
+        if (component && componentIsReferencedFn(component.name, packageName)) {
+          return
+        }
+      }
+    }
+
+    report({
+      path,
+      info: {
+        title: `Unused package`,
+        description: `Package is installed, but none of its formulas, actions, or components are used by any other part of the project. The package can safely be uninstalled.`,
+      },
+      fixes: ['uninstall-package'],
+    })
+  },
+  fixes: {
+    'uninstall-package': removeFromPathFix,
+  },
+}
+
+export type NoReferenceProjectPackageRuleFix = 'uninstall-package'