theprogrammablemind_4wp 9.5.1-beta.6 → 9.5.1-beta.8

package/package.json

@@ -45,6 +45,7 @@
     "runtime.js",
     "src/helpers.js",
     "src/flatten.js",
+    "src/fragments.js",
     "src/unflatten.js",
     "src/config.js",
     "src/configHelpers.js",
@@ -71,6 +72,6 @@
     "sort-json": "^2.0.0",
     "uuid": "^8.3.2"
   },
-  "version": "9.5.1-beta.6",
+  "version": "9.5.1-beta.8",
   "license": "UNLICENSED"
 }

package/src/fragments.js

@@ -0,0 +1,126 @@
+const _ = require('lodash')
+const helpers = require('./helpers')
+
+function fragmentInstantiator(args, contexts) {
+  return new Object({
+    contexts: () => contexts,
+
+    instantiate: async (mappings) => {
+      const root = _.cloneDeep(contexts);
+
+      // To prevent infinite loops on circular references
+      const visited = new WeakSet();
+
+      // Stack item: { node, path }
+      // path is an array like: [], ['user'], ['users', 0], ['users', 0, 'address']
+      const todo = [{ node: root, path: [] }];
+
+      args = { ...args };
+
+      while (todo.length > 0) {
+        const { node, path } = todo.pop();
+
+        // Skip non-compound values early
+        if (!helpers.isCompound(node)) continue;
+
+        // Prevent reprocessing (including circular refs)
+        if (visited.has(node)) continue;
+        visited.add(node);
+
+        // Attach clean, frozen path array (non-enumerable)
+        Object.defineProperty(node, '__path', {
+          value: Object.freeze(path.slice()), // immutable copy
+          writable: false,
+          enumerable: false,
+          configurable: false
+        });
+
+        // Helpful string version
+        Object.defineProperty(node, '__pathString', {
+          value: path.map(p => String(p)).join('.'),
+          enumerable: false
+        });
+
+        // Pass rich context to mappings
+        args.context = node;
+        args.path = path;                    // e.g. ['users', 0, 'profile']
+        args.pathString = path.map(p => String(p)).join('.'); // "users.0.profile"
+
+        // Apply mappings
+        for (const mapping of mappings) {
+          if (await mapping.match(args)) {
+            await mapping.apply(args);
+          }
+        }
+
+        // Traverse children — build path correctly for objects AND arrays
+        if (Array.isArray(node)) {
+          node.forEach((child, index) => {
+            if (helpers.isCompound(child)) {
+              todo.push({
+                node: child,
+                path: [...path, index]  // index as number!
+              });
+            }
+          });
+        } else {
+          // Plain object
+          for (const key of Object.keys(node)) {
+            const child = node[key];
+            if (helpers.isCompound(child)) {
+              todo.push({
+                node: child,
+                path: [...path, key]  // key as string
+              });
+            }
+          }
+        }
+      }
+
+      return root;
+    }
+  });
+}
+
+async function fragmentMapperInstantiator(values, modelFrom, modelTo) {
+  const paths = {}
+  for (const value of values) {
+    paths[value] = { value }
+  }
+
+  {
+    const fi = fragmentInstantiator({paths}, modelFrom)
+    await fi.instantiate([
+      {
+        match: ({context, path}) => values.includes(context.value),
+        apply: ({context, path}) => paths[context.value].from = path
+      },
+    ])
+  }
+
+  {
+    const fi = fragmentInstantiator({paths}, modelTo)
+    await fi.instantiate([
+      {
+        match: ({context, path}) => values.includes(context.value),
+        apply: ({context, path}) => paths[context.value].to = path
+      },
+    ])
+  }
+  return {
+    instantiate: (actualFrom) => {
+      const actualTo = structuredClone(modelTo)
+      for (const value in paths) {
+        const { from, to } = paths[value]
+        const actualValue = helpers.getByPath(actualFrom, from, null)
+        helpers.setByPath(actualTo, to, actualValue)
+      }
+      return actualTo
+    }
+  }
+}
+
+module.exports = {
+  fragmentInstantiator,
+  fragmentMapperInstantiator,
+}