@bian-womp/spark-graph 0.1.20 → 0.1.22

package/lib/cjs/index.cjs

@@ -1,5 +1,34 @@
 'use strict';
 
+function typed(typeId, value) {
+    return { __spark_type: typeId, __spark_value: value };
+}
+function isTypedOutput(v) {
+    return (!!v &&
+        typeof v === "object" &&
+        Object.prototype.hasOwnProperty.call(v, "__spark_type"));
+}
+function getTypedOutputTypeId(v) {
+    if (isTypedOutput(v))
+        return String(v.__spark_type);
+    return undefined;
+}
+function getTypedOutputValue(v) {
+    if (isTypedOutput(v))
+        return v.__spark_value;
+    return v;
+}
+function getInputTypeId(inputs, handle) {
+    const v = inputs ? inputs[handle] : undefined;
+    if (!v)
+        return undefined;
+    return typeof v === "string" ? v : v.typeId;
+}
+function isInputPrivate(inputs, handle) {
+    const v = inputs ? inputs[handle] : undefined;
+    return !!(v && typeof v === "object" && v.private);
+}
+
 class CategoryRegistry {
     constructor() {
         this.categories = new Map();
@@ -372,25 +401,6 @@ class Registry {
     }
 }
 
-function typed(typeId, value) {
-    return { __spark_type: typeId, __spark_value: value };
-}
-function isTypedOutput(v) {
-    return (!!v &&
-        typeof v === "object" &&
-        Object.prototype.hasOwnProperty.call(v, "__spark_type"));
-}
-function getInputTypeId(inputs, handle) {
-    const v = inputs ? inputs[handle] : undefined;
-    if (!v)
-        return undefined;
-    return typeof v === "string" ? v : v.typeId;
-}
-function isInputPrivate(inputs, handle) {
-    const v = inputs ? inputs[handle] : undefined;
-    return !!(v && typeof v === "object" && v.private);
-}
-
 class GraphRuntime {
     constructor() {
         this.nodes = new Map();
@@ -565,12 +575,12 @@ class GraphRuntime {
                 });
                 if (anyAsync) {
                     convertAsync = async (v, signal) => {
-                        if (!isTypedOutput(v))
+                        const typeId = getTypedOutputTypeId(v);
+                        if (!typeId)
                             throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
-                        const typeId = String(v.__spark_type);
                         if (!srcTypes.includes(typeId))
                             throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
-                        const payload = v.__spark_value;
+                        const payload = typeId;
                         const res = registry.resolveCoercion(typeId, dstDeclared);
                         if (!res)
                             return payload;
@@ -581,12 +591,12 @@ class GraphRuntime {
                 }
                 else {
                     convert = (v) => {
-                        if (!isTypedOutput(v))
+                        const typeId = getTypedOutputTypeId(v);
+                        if (!typeId)
                             throw new Error(`Typed output required for union source; allowed: ${srcTypes.join("|")}`);
-                        const typeId = String(v.__spark_type);
                         if (!srcTypes.includes(typeId))
                             throw new Error(`Invalid typed output ${typeId}; allowed: ${srcTypes.join("|")}`);
-                        const payload = v.__spark_value;
+                        const payload = typeId;
                         const res = registry.resolveCoercion(typeId, dstDeclared);
                         if (!res)
                             return payload;
@@ -777,9 +787,7 @@ class GraphRuntime {
             handle: srcHandle,
             value,
             io: "output",
-            runtimeTypeId: isTypedOutput(value)
-                ? String(value.__spark_type)
-                : undefined,
+            runtimeTypeId: getTypedOutputTypeId(value),
         });
         // fan-out along all edges from this output
         const outEdges = this.edges.filter((e) => e.source.nodeId === srcNodeId && e.source.handle === srcHandle);
@@ -811,7 +819,7 @@ class GraphRuntime {
                     handle: e.target.handle,
                     value: v,
                     io: "input",
-                    runtimeTypeId: isTypedOutput(v) ? String(v.__spark_type) : undefined,
+                    runtimeTypeId: getTypedOutputTypeId(v),
                 });
                 if (!this.paused && this.allInboundHaveValue(e.target.nodeId))
                     this.scheduleInputsChanged(e.target.nodeId);
@@ -1778,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")
@@ -1816,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) &&
@@ -2209,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) {
@@ -2487,6 +2774,8 @@ exports.createSimpleGraphRegistry = createSimpleGraphRegistry;
 exports.createValidationGraphDef = createValidationGraphDef;
 exports.createValidationGraphRegistry = createValidationGraphRegistry;
 exports.getInputTypeId = getInputTypeId;
+exports.getTypedOutputTypeId = getTypedOutputTypeId;
+exports.getTypedOutputValue = getTypedOutputValue;
 exports.isInputPrivate = isInputPrivate;
 exports.isTypedOutput = isTypedOutput;
 exports.registerDelayNode = registerDelayNode;