@nordcraft/search 1.0.53 → 1.0.55

package/src/rules/formulas/legacyFormulaRule.ts

@@ -1,184 +0,0 @@
-import type { FunctionOperation } from '@nordcraft/core/dist/formula/formula'
-import { isToddleFormula } from '@nordcraft/core/dist/formula/formulaTypes'
-import { isDefined } from '@nordcraft/core/dist/utils/util'
-import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
-import type { Rule } from '../../types'
-import { replaceLegacyFormula } from './legacyFormulaRule.fix'
-
-export const legacyFormulaRule: Rule<{
-  name: string
-}> = {
-  code: 'legacy formula',
-  level: 'warning',
-  category: 'Deprecation',
-  visit: (report, data) => {
-    if (
-      data.nodeType !== 'formula' ||
-      data.value.type !== 'function' ||
-      !isLegacyFormula(data.value, data.files)
-    ) {
-      return
-    }
-    report(
-      data.path,
-      { name: data.value.name },
-      // The TYPE and BOOLEAN formulas cannot be autofixed since the logic has changed between the 2 implementations
-      data.value.name !== 'TYPE' && data.value.name !== 'BOOLEAN'
-        ? ['replace-legacy-formula']
-        : undefined,
-    )
-  },
-  fixes: {
-    'replace-legacy-formula': replaceLegacyFormula,
-  },
-}
-
-export type LegacyFormulaRuleFix = 'replace-legacy-formula'
-
-const isLegacyFormula = (
-  formula: FunctionOperation,
-  files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>,
-) => {
-  const pluginFormula = files.formulas?.[formula.name]
-
-  if (
-    isUpperCase(formula.name) &&
-    isDefined(pluginFormula) &&
-    !isToddleFormula(pluginFormula) &&
-    pluginFormula.version === undefined &&
-    (builtInFormulas.has(formula.name.toLowerCase()) ||
-      legacyFormulas.has(formula.name.toLowerCase()))
-  ) {
-    return true
-  } else {
-    return false
-  }
-}
-
-const isUpperCase = (str: string) => str === str.toUpperCase()
-
-const legacyFormulas = new Set([
-  'and',
-  'concat',
-  'default',
-  'delete',
-  'drop_last',
-  'eq',
-  'find index',
-  'flat',
-  'gt',
-  'gte',
-  'group_by',
-  'if',
-  'index of',
-  'json_parse',
-  'key_by',
-  'list',
-  'lower',
-  'lt',
-  'lte',
-  'mod',
-  'neq',
-  'or',
-  'random',
-  'size',
-  'sqrt',
-  'starts_with',
-  'take_last',
-  'type',
-  'upper',
-  'uri_encode',
-])
-
-// cSpell: disable
-const builtInFormulas = new Set([
-  'absolute',
-  'add',
-  'append',
-  'boolean',
-  'canshare',
-  'capitalize',
-  'clamp',
-  'concatenate',
-  'currenturl',
-  'datefromstring',
-  'datefromtimestamp',
-  'decodebase64',
-  'decodeuricomponent',
-  'defaultto',
-  'deletekey',
-  'divide',
-  'drop',
-  'droplast',
-  'encodebase64',
-  'encodejson',
-  'encodeuricomponent',
-  'entries',
-  'equals',
-  'every',
-  'filter',
-  'find',
-  'findindex',
-  'findlast',
-  'first',
-  'flatten',
-  'formatdate',
-  'formatnumber',
-  'fromentries',
-  'get',
-  'getelementbyid',
-  'getfromlocalstorage',
-  'getfromsessionstorage',
-  'greaterorequeal',
-  'greaterthan',
-  'groupby',
-  'includes',
-  'indexof',
-  'join',
-  'json',
-  'keyby',
-  'last',
-  'lastindexof',
-  'lessorequal',
-  'lessthan',
-  'lowercase',
-  'map',
-  'matches',
-  'max',
-  'min',
-  'minus',
-  'modulo',
-  'multiply',
-  'not',
-  'notequal',
-  'now',
-  'number',
-  'parsejson',
-  'parseurl',
-  'randomnumber',
-  'range',
-  'reduce',
-  'replaceall',
-  'reverse',
-  'round',
-  'rounddown',
-  'roundup',
-  'set',
-  'shuffle',
-  'size',
-  'some',
-  'sort_by',
-  'split',
-  'squareroot',
-  'startswith',
-  'string',
-  'sum',
-  'take',
-  'takelast',
-  'timestamp',
-  'trim',
-  'typeof',
-  'unique',
-  'uppercase',
-])
-// cSpell: enable

package/src/rules/formulas/noReferenceComponentFormulaRule.test.ts

@@ -1,344 +0,0 @@
-import { HeadTagTypes } from '@nordcraft/core/dist/component/component.types'
-import { describe, expect, test } from 'bun:test'
-import { searchProject } from '../../searchProject'
-import { noReferenceComponentFormulaRule } from './noReferenceComponentFormulaRule'
-
-describe('noReferenceComponentFormulaRule', () => {
-  test('should detect component formulas with no references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {
-                'my-formula': {
-                  name: 'my-formula',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [
-                      {
-                        name: 'Input',
-                        formula: { type: 'value', value: 5 },
-                      },
-                    ],
-                  },
-                  arguments: [],
-                  memoize: false,
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {
-                'my-variable': {
-                  initialValue: { type: 'value', value: 5 },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentFormulaRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component formula')
-    expect(problems[0].path).toEqual([
-      'components',
-      'page',
-      'formulas',
-      'my-formula',
-    ])
-  })
-
-  test('should not detect component formulas with references', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {
-                'my-formula': {
-                  name: 'my-formula',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [
-                      {
-                        name: 'Input',
-                        formula: { type: 'value', value: 5 },
-                      },
-                    ],
-                  },
-                  arguments: [],
-                  memoize: false,
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-                'my-formula2': {
-                  name: 'my-formula2',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [],
-                  },
-                  arguments: [],
-                  memoize: false,
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {
-                'my-variable': {
-                  initialValue: {
-                    type: 'apply',
-                    name: 'my-formula',
-                    arguments: [],
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              route: {
-                info: {
-                  meta: {
-                    xyz: {
-                      tag: HeadTagTypes.Script,
-                      attrs: {},
-                      content: {
-                        type: 'apply',
-                        name: 'my-formula2',
-                        arguments: [],
-                      },
-                    },
-                  },
-                },
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentFormulaRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should not detect component formulas with references through context', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {
-                'my-formula': {
-                  name: 'my-formula',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [
-                      {
-                        name: 'Input',
-                        formula: { type: 'value', value: 5 },
-                      },
-                    ],
-                  },
-                  arguments: [],
-                  memoize: false,
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-            'my-component': {
-              name: 'my-component',
-              nodes: {},
-
-              apis: {},
-              attributes: {},
-              variables: {
-                'my-variable': {
-                  initialValue: {
-                    type: 'path',
-                    path: ['Contexts', 'page', 'my-formula'],
-                  },
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              contexts: {
-                page: {
-                  formulas: ['my-formula'],
-                  workflows: [],
-                },
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentFormulaRule],
-      }),
-    )
-
-    expect(problems).toEqual([])
-  })
-
-  test('should report when subscribed, but no usage', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {
-                'my-formula': {
-                  name: 'my-formula',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [
-                      {
-                        name: 'Input',
-                        formula: { type: 'value', value: 5 },
-                      },
-                    ],
-                  },
-                  arguments: [],
-                  memoize: false,
-                  exposeInContext: true,
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-            'my-component': {
-              name: 'my-component',
-              nodes: {},
-
-              apis: {},
-              attributes: {},
-              variables: {},
-              contexts: {
-                page: {
-                  formulas: ['my-formula'],
-                  workflows: [],
-                },
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentFormulaRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component formula')
-    expect(problems[0].details).toEqual({
-      contextSubscribers: ['my-component'],
-      name: 'my-formula',
-    })
-  })
-
-  test('should detect formulas that only reference themselves', () => {
-    const problems = Array.from(
-      searchProject({
-        files: {
-          components: {
-            page: {
-              name: 'my-page',
-              nodes: {},
-              formulas: {
-                'my-formula': {
-                  name: 'my-formula',
-                  formula: {
-                    type: 'function',
-                    name: '@toddle/number',
-                    arguments: [
-                      {
-                        name: 'Input',
-                        formula: {
-                          type: 'apply',
-                          name: 'my-formula',
-                          arguments: [],
-                        },
-                      },
-                    ],
-                  },
-                  arguments: [],
-                  '@nordcraft/metadata': {
-                    comments: null,
-                  },
-                },
-              },
-              apis: {},
-              attributes: {},
-              variables: {},
-              route: {
-                info: {},
-                path: [],
-                query: {},
-              },
-            },
-          },
-        },
-        rules: [noReferenceComponentFormulaRule],
-      }),
-    )
-
-    expect(problems).toHaveLength(1)
-    expect(problems[0].code).toBe('no-reference component formula')
-    expect(problems[0].path).toEqual([
-      'components',
-      'page',
-      'formulas',
-      'my-formula',
-    ])
-  })
-})

package/src/rules/formulas/noReferenceComponentFormulaRule.ts

@@ -1,92 +0,0 @@
-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
-  contextSubscribers: string[]
-}> = {
-  code: 'no-reference component formula',
-  level: 'warning',
-  category: 'No References',
-  visit: (report, args) => {
-    if (args.nodeType !== 'component-formula') {
-      return
-    }
-
-    const { path, files, value, component } = args
-    const [, componentName, , formulaKey] = path
-    for (const {
-      path: formulaPath,
-      formula,
-    } of component.formulasInComponent()) {
-      if (
-        formula.type === 'apply' &&
-        formula.name === formulaKey &&
-        // Disregard own formula reference.
-        // Similar to typescript etc. we do not report purely circular references, only references to self:
-        // A -> B -> A is not reported as unused, as removing A would break B and vice versa. Even if they are
-        // ultimately unused, removing one and breaking the other is likely an unintended side effect.
-        !(formulaPath[0] === 'formulas' && formulaPath[1] === formulaKey)
-      ) {
-        return
-      }
-    }
-
-    // Short circuit if the component is exported and the formula is exposed in context, as it is always indirectly used
-    if (value.exposeInContext && component.exported) {
-      return
-    }
-
-    // It is possible that a formula is never used, but still has subscribers
-    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
-        const component = _component!
-        for (const [contextKey, context] of Object.entries(
-          component.contexts ?? {},
-        )) {
-          if (
-            contextKey === componentName &&
-            context.formulas.includes(formulaKey.toString())
-          ) {
-            contextSubscribers.push(component.name)
-            const contextComponent = new ToddleComponent({
-              component,
-              getComponent: (name) => files.components[name],
-              packageName: undefined,
-              globalFormulas: {
-                formulas: files.formulas,
-                packages: files.packages,
-              },
-            })
-            for (const { formula } of contextComponent.formulasInComponent()) {
-              if (
-                formula.type === 'path' &&
-                formula.path[0] === 'Contexts' &&
-                formula.path[1] === componentName &&
-                formula.path[2] === formulaKey
-              ) {
-                return
-              }
-            }
-          }
-        }
-      }
-    }
-    report(
-      args.path,
-      {
-        contextSubscribers,
-        name: value.name,
-      },
-      ['delete-component-formula'],
-    )
-  },
-  fixes: {
-    'delete-component-formula': removeFromPathFix,
-  },
-}
-
-export type NoReferenceComponentFormulaRuleFix = 'delete-component-formula'