@nordcraft/search 1.0.43 → 1.0.44

package/src/rules/actions/legacyActionRule.ts

@@ -1,11 +1,6 @@
-import type {
-  ActionModel,
-  CustomActionArgument,
-} from '@nordcraft/core/dist/component/component.types'
-import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
-import { set } from '@nordcraft/core/dist/utils/collections'
 import type { Rule } from '../../types'
-import { isLegacyAction, renameArguments } from '../../util/helpers'
+import { isLegacyAction } from '../../util/helpers'
+import { replaceLegacyAction } from './legacyActionRule.fix'
 
 export const legacyActionRule: Rule<{
   name: string
@@ -39,158 +34,7 @@ export const legacyActionRule: Rule<{
     }
   },
   fixes: {
-    'replace-legacy-action': ({ path, value, nodeType, files }) => {
-      if (nodeType !== 'action-model') {
-        return
-      }
-      if (!isLegacyAction(value)) {
-        return
-      }
-
-      let newAction: ActionModel | undefined
-      switch (value.name) {
-        case 'If': {
-          const trueActions = value.events?.['true']?.actions ?? []
-          const falseActions = value.events?.['false']?.actions ?? []
-          const trueCondition: CustomActionArgument | undefined =
-            (value.arguments ?? [])[0]
-          newAction = {
-            type: 'Switch',
-            cases: [
-              {
-                condition: trueCondition?.formula ?? null,
-                actions: trueActions,
-              },
-            ],
-            default: { actions: falseActions },
-          }
-          break
-        }
-        case 'PreventDefault': {
-          newAction = {
-            name: '@toddle/preventDefault',
-            arguments: [],
-            label: 'Prevent default',
-          }
-          break
-        }
-        case 'StopPropagation': {
-          newAction = {
-            name: '@toddle/stopPropagation',
-            arguments: [],
-            label: 'Stop propagation',
-          }
-          break
-        }
-        case 'UpdateVariable':
-        case 'Update Variable': {
-          const variableName =
-            value.arguments?.[0]?.formula.type === 'value'
-              ? value.arguments[0].formula.value
-              : undefined
-          if (typeof variableName !== 'string') {
-            break
-          }
-          const variableValue = value.arguments?.[1]?.formula
-          if (!variableValue) {
-            break
-          }
-          newAction = {
-            type: 'SetVariable',
-            variable: variableName,
-            data: variableValue,
-          }
-          break
-        }
-        case 'SetTimeout': {
-          newAction = {
-            ...value,
-            name: '@toddle/sleep',
-            arguments: renameArguments(
-              { 'Delay in ms': 'Delay in milliseconds' },
-              value.arguments,
-            ),
-            events: value.events?.['timeout']
-              ? { tick: value.events.timeout }
-              : undefined,
-            label: 'Sleep',
-          }
-          break
-        }
-        case 'SetInterval': {
-          newAction = {
-            ...value,
-            name: '@toddle/interval',
-            arguments: renameArguments(
-              { 'Interval in ms': 'Interval in milliseconds' },
-              value.arguments,
-            ),
-            label: 'Interval',
-          }
-          break
-        }
-        case 'Debug': {
-          newAction = {
-            ...value,
-            name: '@toddle/logToConsole',
-            label: 'Log to console',
-          }
-          break
-        }
-        case 'GoToURL': {
-          newAction = {
-            name: '@toddle/gotToURL', // Yes, the typo is in the action name
-            arguments: renameArguments({ url: 'URL' }, value.arguments),
-            label: 'Go to URL',
-          }
-          break
-        }
-        case 'TriggerEvent': {
-          const eventName =
-            value.arguments?.[0]?.formula.type === 'value'
-              ? value.arguments[0].formula.value
-              : undefined
-          if (typeof eventName !== 'string') {
-            break
-          }
-          const eventData = value.arguments?.[1]?.formula
-          if (!eventData) {
-            break
-          }
-          newAction = {
-            type: 'TriggerEvent',
-            event: eventName,
-            data: eventData,
-          }
-          break
-        }
-        case 'FocusElement': {
-          newAction = {
-            name: '@toddle/focus',
-            arguments: [
-              {
-                name: 'Element',
-                formula: {
-                  type: 'function',
-                  name: '@toddle/getElementById',
-                  arguments: [
-                    {
-                      name: 'Id',
-                      formula:
-                        value.arguments?.[0]?.formula ?? valueFormula(null),
-                    },
-                  ],
-                },
-              },
-            ],
-            label: 'Focus',
-          }
-        }
-      }
-      if (newAction) {
-        return set(files, path, newAction)
-      }
-    },
+    'replace-legacy-action': replaceLegacyAction,
   },
 }
 

package/src/rules/actions/noReferenceProjectActionRule.ts

@@ -1,61 +1,53 @@
 import type { CustomActionModel } from '@nordcraft/core/dist/component/component.types'
 import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
-import { omit } from '@nordcraft/core/dist/utils/collections'
-import type { NodeType, Rule } from '../../types'
+import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceProjectActionRule: Rule<void> = {
   code: 'no-reference project action',
   level: 'warning',
   category: 'No References',
-  visit: (report, details) => {
-    if (!hasReferences(details)) {
-      report(details.path, undefined, ['delete-project-action'])
+  visit: (report, { value, path, files, nodeType, memo }) => {
+    if (nodeType !== 'project-action' || value.exported === true) {
+      return
+    }
+
+    const projectActionReferences = memo('projectActionReferences', () => {
+      const usedActions = 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, packageName) =>
+            packageName
+              ? files.packages?.[packageName]?.components[name]
+              : files.components[name],
+          packageName: undefined,
+          globalFormulas: {
+            formulas: files.formulas,
+            packages: files.packages,
+          },
+        })
+        for (const [, action] of c.actionModelsInComponent()) {
+          if (
+            action.type === 'Custom' ||
+            action.type === ('function' as any) ||
+            action.type === undefined
+          ) {
+            usedActions.add((action as CustomActionModel).name)
+          }
+        }
+      }
+      return usedActions
+    })
+
+    if (!projectActionReferences.has(value.name)) {
+      report(path, undefined, ['delete-project-action'])
     }
   },
   fixes: {
-    'delete-project-action': (data) => {
-      if (!hasReferences(data)) {
-        return omit(data.files, data.path)
-      }
-    },
+    'delete-project-action': removeFromPathFix,
   },
 }
 
 export type NoReferenceProjectActionRuleFix = 'delete-project-action'
-
-const hasReferences = ({ value, files, nodeType, memo }: NodeType) => {
-  if (nodeType !== 'project-action' || value.exported === true) {
-    return true
-  }
-
-  const projectActionReferences = memo('projectActionReferences', () => {
-    const usedActions = 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, packageName) =>
-          packageName
-            ? files.packages?.[packageName]?.components[name]
-            : files.components[name],
-        packageName: undefined,
-        globalFormulas: {
-          formulas: files.formulas,
-          packages: files.packages,
-        },
-      })
-      for (const [, action] of c.actionModelsInComponent()) {
-        if (
-          action.type === 'Custom' ||
-          action.type === ('function' as any) ||
-          action.type === undefined
-        ) {
-          usedActions.add((action as CustomActionModel).name)
-        }
-      }
-    }
-    return usedActions
-  })
-
-  return projectActionReferences.has(value.name)
-}

package/src/rules/apis/noReferenceApiRule.test.ts

@@ -2,11 +2,13 @@ import {
   pathFormula,
   valueFormula,
 } from '@nordcraft/core/dist/formula/formulaUtils'
+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 { noReferenceApiRule } from './noReferenceApiRule'
 
-describe('noReferenceApiRule', () => {
+describe('find noReferenceApiRule', () => {
   test('should detect APIs with no references', () => {
     const problems = Array.from(
       searchProject({
@@ -163,3 +165,67 @@ describe('noReferenceApiRule', () => {
     expect(problems).toEqual([])
   })
 })
+
+describe('fix noReferenceApiRule', () => {
+  test('should remove unused APIs', () => {
+    const project: ProjectFiles = {
+      formulas: {},
+      components: {
+        apiComponent: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {
+            'my-legacy-api': {
+              name: 'my-legacy-api',
+              type: 'REST',
+              autoFetch: valueFormula(true),
+              onCompleted: null,
+              onFailed: null,
+            },
+            'my-api': {
+              name: 'my-api',
+              type: 'http',
+              version: 2,
+              autoFetch: valueFormula(true),
+              inputs: {},
+              '@nordcraft/metadata': {
+                comments: null,
+              },
+            },
+            'used-api': {
+              name: 'used-api',
+              type: 'http',
+              version: 2,
+              autoFetch: valueFormula(true),
+              inputs: {},
+            },
+          },
+          onLoad: {
+            trigger: 'onLoad',
+            actions: [
+              {
+                type: 'Fetch',
+                api: 'used-api',
+                inputs: {},
+                onSuccess: { actions: [] },
+                onError: { actions: [] },
+              },
+            ],
+          },
+          attributes: {},
+          variables: {},
+        },
+      },
+    }
+    const fixedProject = fixProject({
+      files: project,
+      rule: noReferenceApiRule,
+      fixType: 'delete-api',
+    })
+    // 2/3 APIs should be removed
+    expect(Object.keys(fixedProject.components['apiComponent']!.apis)).toEqual([
+      'used-api',
+    ])
+  })
+})

package/src/rules/apis/noReferenceApiRule.ts

@@ -1,4 +1,5 @@
 import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceApiRule: Rule<void> = {
   code: 'no-reference api',
@@ -8,7 +9,8 @@ export const noReferenceApiRule: Rule<void> = {
     if (args.nodeType !== 'component-api') {
       return
     }
-    const { path, value, memo, component } = args
+    const { value, memo, component } = args
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!component) {
       return
     }
@@ -37,6 +39,11 @@ export const noReferenceApiRule: Rule<void> = {
     if (componentApiReferences.has(value.name)) {
       return
     }
-    report(path)
+    report(args.path, undefined, ['delete-api'])
+  },
+  fixes: {
+    'delete-api': removeFromPathFix,
   },
 }
+
+export type NoReferenceApiRuleFix = 'delete-api'

package/src/rules/attributes/noReferenceAttributeRule.test.ts

@@ -1,8 +1,10 @@
+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 { noReferenceAttributeRule } from './noReferenceAttributeRule'
 
-describe('noReferenceAttributeRule', () => {
+describe('find noReferenceAttributeRule', () => {
   test('should detect attributes with no references', () => {
     const problems = Array.from(
       searchProject({
@@ -137,3 +139,35 @@ describe('noReferenceAttributeRule', () => {
     expect(problems).toEqual([])
   })
 })
+
+describe('fix noReferenceAttributeRule', () => {
+  test('should remove attributes with no references', () => {
+    const files: ProjectFiles = {
+      formulas: {},
+      components: {
+        test: {
+          name: 'test',
+          nodes: {},
+          formulas: {},
+          apis: {},
+          attributes: {
+            'my-attribute': {
+              name: 'my-attribute-name',
+              testValue: { type: 'value', value: null },
+              '@nordcraft/metadata': {
+                comments: null,
+              },
+            },
+          },
+          variables: {},
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: noReferenceAttributeRule,
+      fixType: 'delete-attribute',
+    })
+    expect(fixedFiles.components['test']?.attributes).toEqual({})
+  })
+})

package/src/rules/attributes/noReferenceAttributeRule.ts

@@ -1,4 +1,5 @@
 import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceAttributeRule: Rule<void> = {
   code: 'no-reference attribute',
@@ -26,7 +27,11 @@ export const noReferenceAttributeRule: Rule<void> = {
     if (attrs.has(attributeKey)) {
       return
     }
-
-    report(path)
+    report(args.path, undefined, ['delete-attribute'])
+  },
+  fixes: {
+    'delete-attribute': removeFromPathFix,
   },
 }
+
+export type NoReferenceAttributeRuleFix = 'delete-attribute'

package/src/rules/components/noReferenceComponentRule.ts

@@ -1,53 +1,42 @@
 import type { Component } from '@nordcraft/core/dist/component/component.types'
-import { omit } from '@nordcraft/core/dist/utils/collections'
 import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { ApplicationState, NodeType, Rule } from '../../types'
+import type { Rule } from '../../types'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceComponentRule: Rule<void> = {
   code: 'no-reference component',
   level: 'warning',
   category: 'No References',
   visit: (report, data, state) => {
-    if (hasReferences(data, state)) {
+    if (
+      data.nodeType !== 'component' ||
+      isPage(data.value) ||
+      (state?.projectDetails?.type === 'package' &&
+        data.value.exported === true)
+    ) {
       return
     }
+    for (const component of Object.values(data.files.components)) {
+      // Enforce that the component is not undefined since we're iterating
+      for (const node of Object.values(component!.nodes ?? {})) {
+        if (
+          node.type === 'component' &&
+          node.name === data.value.name &&
+          // Circular references from a component to itself should
+          // not count as a reference
+          node.name !== component!.name
+        ) {
+          return
+        }
+      }
+    }
     report(data.path, undefined, ['delete-component'])
   },
   fixes: {
-    'delete-component': (data, state) => {
-      if (hasReferences(data, state)) {
-        return
-      }
-      return omit(data.files, data.path)
-    },
+    'delete-component': removeFromPathFix,
   },
 }
 
-const hasReferences = (data: NodeType, state?: ApplicationState) => {
-  if (
-    data.nodeType !== 'component' ||
-    isPage(data.value) ||
-    (state?.projectDetails?.type === 'package' && data.value.exported === true)
-  ) {
-    return true
-  }
-  for (const component of Object.values(data.files.components)) {
-    // Enforce that the component is not undefined since we're iterating
-    for (const node of Object.values(component!.nodes ?? {})) {
-      if (
-        node.type === 'component' &&
-        node.name === data.value.name &&
-        // Circular references from a component to itself should
-        // not count as a reference
-        node.name !== component!.name
-      ) {
-        return true
-      }
-    }
-  }
-  return false
-}
-
 export type NoReferenceComponentRuleFix = 'delete-component'
 
 const isPage = (

package/src/rules/events/noReferenceEventRule.test.ts

@@ -1,9 +1,11 @@
 import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
+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 { noReferenceEventRule } from './noReferenceEventRule'
 
-describe('noReferenceEventRule', () => {
+describe('find noReferenceEventRule', () => {
   test('should detect events with no references', () => {
     const problems = Array.from(
       searchProject({
@@ -146,3 +148,59 @@ describe('noReferenceEventRule', () => {
     expect(problems).toEqual([])
   })
 })
+
+describe('fix noReferenceEventRule', () => {
+  test('should remove events with no references', () => {
+    const files: ProjectFiles = {
+      components: {
+        test: {
+          name: 'test',
+          nodes: {
+            root: {
+              type: 'element',
+              attrs: {},
+              classes: {},
+              events: {
+                click: {
+                  trigger: 'click',
+                  actions: [
+                    {
+                      type: 'TriggerEvent',
+                      event: 'unknown-event',
+                      data: valueFormula(null),
+                    },
+                  ],
+                },
+              },
+              tag: 'div',
+              children: [],
+              style: {},
+            },
+          },
+          formulas: {},
+          apis: {},
+          attributes: {},
+          variables: {},
+          events: [
+            {
+              name: 'unused-event',
+              // eslint-disable-next-line inclusive-language/use-inclusive-words
+              dummyEvent: {
+                name: 'Name',
+              },
+              '@nordcraft/metadata': {
+                comments: null,
+              },
+            },
+          ],
+        },
+      },
+    }
+    const fixedFiles = fixProject({
+      files,
+      rule: noReferenceEventRule,
+      fixType: 'delete-event',
+    })
+    expect(fixedFiles.components['test']?.events).toEqual([])
+  })
+})

package/src/rules/events/noReferenceEventRule.ts

@@ -1,5 +1,6 @@
 import type { Rule } from '../../types'
 import { isLegacyAction } from '../../util/helpers'
+import { removeFromPathFix } from '../../util/removeUnused.fix'
 
 export const noReferenceEventRule: Rule<{ name: string }> = {
   code: 'no-reference event',
@@ -9,7 +10,7 @@ export const noReferenceEventRule: Rule<{ name: string }> = {
     if (args.nodeType !== 'component-event') {
       return
     }
-    const { path, memo, value } = args
+    const { memo, value } = args
     const { component, event } = value
     const events = memo(`${component.name}-events`, () => {
       const events = new Set<string>()
@@ -40,7 +41,11 @@ export const noReferenceEventRule: Rule<{ name: string }> = {
     if (events.has(event.name)) {
       return
     }
-
-    report(path, { name: event.name })
+    report(args.path, { name: args.value.event.name }, ['delete-event'])
+  },
+  fixes: {
+    'delete-event': removeFromPathFix,
   },
 }
+
+export type NoReferenceEventRuleFix = 'delete-event'