@bian-womp/spark-graph 0.1.21 → 0.1.22

package/lib/cjs/index.cjs

@@ -1786,6 +1786,96 @@ const lcg = (seed) => {
     let s = seed >>> 0 || 1;
     return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
 };
+// JSON Pointer helpers (RFC 6901 subset)
+function jsonPointerGet(obj, pointer) {
+    if (!pointer || pointer === "/")
+        return obj;
+    if (!pointer.startsWith("/"))
+        return undefined;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    let cur = obj;
+    for (const key of parts) {
+        if (cur === undefined || cur === null)
+            return undefined;
+        cur = cur[key];
+    }
+    return cur;
+}
+function jsonPointerSet(obj, pointer, value) {
+    if (!pointer || pointer === "/")
+        return value;
+    if (!pointer.startsWith("/"))
+        return obj;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    const root = structuredClone(obj);
+    let cur = root;
+    for (let i = 0; i < parts.length; i++) {
+        const key = parts[i];
+        if (i === parts.length - 1) {
+            if (Array.isArray(cur) && key === "-")
+                cur.push(value);
+            else
+                cur[key] = value;
+        }
+        else {
+            const next = cur[key];
+            if (next === undefined || next === null) {
+                // create container heuristically
+                const nextKey = parts[i + 1];
+                cur[key] =
+                    typeof nextKey === "string" && /^[0-9]+$/.test(nextKey) ? [] : {};
+            }
+            cur = cur[key];
+        }
+    }
+    return root;
+}
+function jsonPointerRemove(obj, pointer) {
+    if (!pointer || pointer === "/")
+        return undefined;
+    if (!pointer.startsWith("/"))
+        return obj;
+    const parts = pointer
+        .split("/")
+        .slice(1)
+        .map((p) => p.replace(/~1/g, "/").replace(/~0/g, "~"));
+    const root = structuredClone(obj);
+    let cur = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const key = parts[i];
+        if (cur === undefined || cur === null)
+            return root;
+        cur = cur[key];
+    }
+    const last = parts[parts.length - 1];
+    if (Array.isArray(cur)) {
+        const idx = last === "-" ? cur.length - 1 : Number(last);
+        if (Number.isFinite(idx))
+            cur.splice(idx, 1);
+    }
+    else if (cur && typeof cur === "object") {
+        delete cur[last];
+    }
+    return root;
+}
+function deepMerge(a, b) {
+    if (Array.isArray(a) && Array.isArray(b))
+        return [...a, ...b];
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const out = { ...a };
+        for (const [k, v] of Object.entries(b)) {
+            out[k] = k in out ? deepMerge(out[k], v) : v;
+        }
+        return out;
+    }
+    return b;
+}
 // JSON helpers
 const isPlainObject = (v) => {
     if (v === null || typeof v !== "object")
@@ -1824,7 +1914,7 @@ function setupBasicGraphRegistry() {
     registry.registerType({
         id: "base.object",
         validate: (v) => isJson(v),
-    }, { withArray: true, arrayPickFirstDefined: true });
+    }, { withArray: false });
     registry.registerType({
         id: "base.vec3",
         validate: (v) => Array.isArray(v) &&
@@ -2217,6 +2307,195 @@ function setupBasicGraphRegistry() {
             },
         },
     });
+    // ------------------------- JSON/object utilities -------------------------
+    registry.registerNode({
+        id: "base.objectGet",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Pointers: "base.string[]" },
+        outputs: { Values: "base.object" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const pointers = (ins.Pointers || []).map(String);
+            const out = {};
+            for (const p of pointers)
+                out[p] = jsonPointerGet(obj, p);
+            return { Values: out };
+        },
+    });
+    registry.registerNode({
+        id: "base.objectSet",
+        categoryId: "compute",
+        inputs: {
+            Object: "base.object",
+            Pointers: "base.string[]",
+            NewValues: "base.string[]",
+        },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const pointers = (ins.Pointers || []).map(String);
+            const values = (ins.NewValues || []).map(String);
+            let cur = structuredClone(ins.Object);
+            for (let i = 0; i < pointers.length; i++) {
+                const p = pointers[i];
+                const raw = values[i];
+                let val = raw;
+                if (typeof raw === "string") {
+                    try {
+                        val = JSON.parse(raw);
+                    }
+                    catch {
+                        /* keep as string */
+                    }
+                }
+                cur = jsonPointerSet(cur, p, val);
+            }
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.objectRemove",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Pointers: "base.string[]" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const pointers = (ins.Pointers || []).map(String);
+            let cur = structuredClone(ins.Object);
+            for (const p of pointers)
+                cur = jsonPointerRemove(cur, p);
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.objectMerge",
+        categoryId: "compute",
+        inputs: { A: "base.object", B: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => ({
+            Result: deepMerge(ins.A, ins.B),
+        }),
+    });
+    registry.registerNode({
+        id: "base.objectKeys",
+        categoryId: "compute",
+        inputs: { Object: "base.object" },
+        outputs: { Keys: "base.string[]" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const keys = isPlainObject(obj)
+                ? Object.keys(obj)
+                : Array.isArray(obj)
+                    ? Object.keys(obj)
+                    : [];
+            return { Keys: keys };
+        },
+    });
+    registry.registerNode({
+        id: "base.objectValues",
+        categoryId: "compute",
+        inputs: { Object: "base.object" },
+        outputs: { Values: "base.object" },
+        impl: (ins) => {
+            const obj = ins.Object;
+            const vals = isPlainObject(obj)
+                ? Object.values(obj)
+                : Array.isArray(obj)
+                    ? Object.values(obj)
+                    : [];
+            return { Values: vals };
+        },
+    });
+    registry.registerNode({
+        id: "base.objectPatch",
+        categoryId: "compute",
+        inputs: { Object: "base.object", Ops: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const root = structuredClone(ins.Object);
+            const opsRaw = ins.Ops;
+            const ops = Array.isArray(opsRaw)
+                ? opsRaw
+                : opsRaw
+                    ? [opsRaw]
+                    : [];
+            let cur = root;
+            for (const op of ops) {
+                if (!op || typeof op !== "object")
+                    continue;
+                const kind = String(op.op || "");
+                const path = String(op.path || "");
+                if (kind === "add" || kind === "replace") {
+                    cur = jsonPointerSet(cur, path, op.value);
+                }
+                else if (kind === "remove") {
+                    cur = jsonPointerRemove(cur, path);
+                }
+                else if (kind === "test") {
+                    const got = jsonPointerGet(cur, path);
+                    const expected = op.value;
+                    const ok = JSON.stringify(got) === JSON.stringify(expected);
+                    if (!ok)
+                        throw new Error(`objectPatch test failed at ${path}`);
+                }
+            }
+            return { Result: cur };
+        },
+    });
+    registry.registerNode({
+        id: "base.arrayConcat",
+        categoryId: "compute",
+        inputs: { A: "base.object", B: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const a = Array.isArray(ins.A) ? ins.A : [];
+            const b = Array.isArray(ins.B) ? ins.B : [];
+            return { Result: [...a, ...b] };
+        },
+    });
+    registry.registerNode({
+        id: "base.arrayFlatten",
+        categoryId: "compute",
+        inputs: { Objects: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Objects) ? ins.Objects : [];
+            const out = [];
+            for (const v of arr) {
+                if (Array.isArray(v))
+                    out.push(...v);
+                else
+                    out.push(v);
+            }
+            return { Result: out };
+        },
+    });
+    registry.registerNode({
+        id: "base.arraySortBy",
+        categoryId: "compute",
+        inputs: { Objects: "base.object", Pointers: "base.string[]" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Objects) ? ins.Objects : [];
+            const pointers = (ins.Pointers || []).map(String);
+            const out = [...arr].sort((a, b) => {
+                for (const p of pointers) {
+                    const av = jsonPointerGet(a, p);
+                    const bv = jsonPointerGet(b, p);
+                    if (av === bv)
+                        continue;
+                    if (av === undefined)
+                        return 1;
+                    if (bv === undefined)
+                        return -1;
+                    if (av < bv)
+                        return -1;
+                    if (av > bv)
+                        return 1;
+                }
+                return 0;
+            });
+            return { Result: out };
+        },
+    });
     return registry;
 }
 function registerDelayNode(registry) {