@nordcraft/search 1.0.45 → 1.0.47

package/src/util/contextlessEvaluateFormula.ts

@@ -0,0 +1,110 @@
+import { type Formula } from '@nordcraft/core/dist/formula/formula'
+
+/**
+ * Static evaluation of a formula.
+ *
+ * Can be used by issues to determine if a formula or sub-formula can be reduced to a static value.
+ * When sophisticated enough, it can be used during compile-time to reduce all static subgraphs of a formula to static values, greatly reducing payload and improving runtime performance.
+ *
+ * @returns {
+ *  isStatic: boolean; // Whether the formula is static (i.e., does not depend on any variables, context AND only use pure formulas (no Random, Date, etc.))
+ *  result: unknown; // The evaluated value of the formula
+ * }
+ *
+ * TODO: Make this function more capable of evaluating pure core formulas.
+ * TODO: Memoize the results (using path or a fast hash) to avoid re-evaluating any similar sub-graphs multiple times.
+ * TODO: Add a complex test-suite to ensure it works and develops as expected.
+ */
+export const contextlessEvaluateFormula = (
+  formula: Formula,
+): {
+  isStatic: boolean
+  result: unknown
+} => {
+  // Very basic implementation, just to get started.
+  switch (formula.type) {
+    case 'value': {
+      return {
+        isStatic: true,
+        result: formula.value,
+      }
+    }
+
+    case 'array': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      return {
+        isStatic: results.every((res) => res.isStatic),
+        result: results.map((res) => res.result),
+      }
+    }
+
+    case 'record': {
+      const entries = Object.entries(formula.entries).map(
+        ([key, arg]) => [key, contextlessEvaluateFormula(arg.formula)] as const,
+      )
+
+      const results = entries.map(([, res]) => res)
+
+      return {
+        isStatic: results.every((res) => res.isStatic),
+        result: Object.fromEntries(
+          entries.map(([key, res]) => [key, res.result]),
+        ),
+      }
+    }
+
+    // Static if:
+    // - ALL conditions are static AND truthy
+    // - ANY condition is static and falsy
+    // - EMPTY argument list is always true
+    case 'and': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      const alwaysTrue =
+        results.length === 0 ||
+        results.every((res) => res.isStatic && Boolean(res.result) === true)
+      const alwaysFalsy = results.some(
+        (res) => res.isStatic && Boolean(res.result) === false,
+      )
+
+      return {
+        isStatic: alwaysTrue || alwaysFalsy,
+        result: alwaysTrue ? true : alwaysFalsy ? false : undefined,
+      }
+    }
+
+    // Static if:
+    // - ANY condition is static AND truthy
+    // - ALL conditions are static AND falsy
+    // - EMPTY argument list is always false
+    case 'or': {
+      const results = formula.arguments.map((arg) =>
+        contextlessEvaluateFormula(arg.formula),
+      )
+
+      const alwaysFalsy =
+        results.length === 0 ||
+        results.every((res) => res.isStatic && Boolean(res.result) === false)
+      const alwaysTrue = results.some(
+        (res) => res.isStatic && Boolean(res.result) === true,
+      )
+
+      return {
+        isStatic: alwaysTrue || alwaysFalsy,
+        result: alwaysFalsy ? false : alwaysTrue ? true : undefined,
+      }
+    }
+
+    default:
+      // For now, we assume that any other formula is not static.
+      return {
+        isStatic: false,
+        result: undefined,
+      }
+  }
+}

package/src/util/helpers.test.ts

@@ -53,7 +53,7 @@ describe('shouldSearchPath', () => {
 })
 
 describe('shouldSearchExactPath', () => {
-  test.only('should only return true for exact matches', () => {
+  test('should only return true for exact matches', () => {
     const pathsToVisit = [
       ['components', 'Button'],
       ['components', 'Input'],

package/src/util/removeUnused.fix.ts

@@ -1,5 +1,33 @@
-import { omit } from '@nordcraft/core/dist/utils/collections'
+import type { NodeModel } from '@nordcraft/core/dist/component/component.types'
+import { get, omit, set } from '@nordcraft/core/dist/utils/collections'
 import type { FixFunction, NodeType } from '../types'
 
 export const removeFromPathFix: FixFunction<NodeType> = ({ path, files }) =>
   omit(files, path)
+
+/**
+ * Same as removeFromPathFix, but also removes the node from its parent's children.
+ */
+export const removeNodeFromPathFix: FixFunction<NodeType> = (data) => {
+  if (data.nodeType !== 'component-node') {
+    throw new Error('removeNodeFromPathFix can only be used on component nodes')
+  }
+
+  const componentNodesPath = data.path.slice(0, -1).map(String)
+  const filesWithoutNode = removeFromPathFix(data)
+  const nodes = get(filesWithoutNode, componentNodesPath) as Record<
+    string,
+    NodeModel
+  >
+  for (const key in nodes) {
+    if (
+      nodes[key].children?.includes(data.path[data.path.length - 1] as string)
+    ) {
+      nodes[key].children = nodes[key].children.filter(
+        (p) => p !== data.path[data.path.length - 1],
+      )
+    }
+  }
+
+  return set(filesWithoutNode, componentNodesPath, nodes)
+}