@nordcraft/search 1.0.89 → 1.0.90

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/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'

package/src/searchProject.ts

@@ -210,6 +210,29 @@ export function* searchProject({
     state,
     fixOptions: fixOptions as any,
   })
+
+  if (files.packages) {
+    for (const key in files.packages) {
+      const pkg = files.packages[key]
+      if (pkg) {
+        yield* visitNode({
+          args: {
+            nodeType: 'project-package',
+            value: pkg,
+            packageName: key,
+            path: ['packages', key],
+            rules,
+            files,
+            pathsToVisit,
+            useExactPaths,
+            memo,
+          },
+          state,
+          fixOptions: fixOptions as any,
+        })
+      }
+    }
+  }
 }
 
 function visitNode(args: {
@@ -345,6 +368,7 @@ function* visitNode({
     case 'project-config':
     case 'project-theme':
     case 'project-theme-property':
+    case 'project-package':
     case 'style-declaration':
     case 'style-variable':
     case 'style-variant':

package/src/types.ts

@@ -27,6 +27,7 @@ import type { StyleVariant } from '@nordcraft/core/dist/styling/variantSelector'
 import type { Nullable, PluginAction } from '@nordcraft/core/dist/types'
 import type {
   ApiService,
+  InstalledPackage,
   ProjectFiles,
   Route,
   ToddleProject,
@@ -50,6 +51,7 @@ import type { NoReferenceComponentFormulaRuleFix } from './rules/issues/formulas
 import type { NoReferenceProjectFormulaRuleFix } from './rules/issues/formulas/noReferenceProjectFormulaRule'
 import type { NoStaticNodeConditionRuleFix } from './rules/issues/logic/noStaticNodeCondition'
 import type { NoReferenceNodeRuleFix } from './rules/issues/miscellaneous/noReferenceNodeRule'
+import type { NoReferenceProjectPackageRuleFix } from './rules/issues/miscellaneous/noReferencePackageRule'
 import type { InvalidStyleSyntaxRuleFix } from './rules/issues/style/invalidStyleSyntaxRule'
 import type { LegacyStyleVariableRuleFix } from './rules/issues/style/legacyStyleVariableRule'
 import type { AddToThemeFix } from './rules/issues/style/unknownCSSVariable'
@@ -91,6 +93,7 @@ export type Code =
   | 'no-reference node'
   | 'no-reference project action'
   | 'no-reference project formula'
+  | 'no-reference project package'
   | 'no-reference variable'
   | 'no-static-node-condition'
   | 'no-unnecessary-condition-falsy'
@@ -376,6 +379,12 @@ export type ProjectConfigNode = {
   value: unknown
 } & Base
 
+export type ProjectPackageNode = {
+  nodeType: 'project-package'
+  value: InstalledPackage
+  packageName: string
+} & Base
+
 export type StyleVariantNode = {
   nodeType: 'style-variant'
   value: {
@@ -435,6 +444,7 @@ export type NodeType =
   | ProjectRoute
   | ProjectThemeNode
   | ProjectThemePropertyNode
+  | ProjectPackageNode
   | StyleNode
   | StyleVariableNode
   | StyleVariantNode
@@ -463,6 +473,7 @@ export type FixType =
   | UnknownActionEventRuleFix
   | UnknownApiServiceRuleFix
   | UnknownComponentAttributeRuleFix
+  | NoReferenceProjectPackageRuleFix
 
 interface ReportedIssueInfo {
   title: string