@bian-womp/spark-graph 0.1.21 → 0.1.23

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) &&
@@ -1883,7 +1973,7 @@ function setupBasicGraphRegistry() {
     });
     // Enums: Math Operation
     registry.registerEnum({
-        id: "base.enum:math.operation",
+        id: "enum:base.math.operation",
         options: [
             { value: 0, label: "Add" },
             { value: 1, label: "Subtract" },
@@ -1893,11 +1983,20 @@ function setupBasicGraphRegistry() {
             { value: 5, label: "Max" },
             { value: 6, label: "Modulo" },
             { value: 7, label: "Power" },
+            // Unary / aggregate operations on A only
+            { value: 8, label: "Round" },
+            { value: 9, label: "Floor" },
+            { value: 10, label: "Ceil" },
+            { value: 11, label: "Abs" },
+            { value: 12, label: "Sum" },
+            { value: 13, label: "Avg" },
+            { value: 14, label: "MinAll" },
+            { value: 15, label: "MaxAll" },
         ],
     });
     // Enums: Compare Operation
     registry.registerEnum({
-        id: "base.enum:compare.operation",
+        id: "enum:base.compare.operation",
         options: [
             { value: 0, label: "LessThan" },
             { value: 1, label: "LessThanOrEqual" },
@@ -2022,7 +2121,7 @@ function setupBasicGraphRegistry() {
         id: "base.math",
         categoryId: "compute",
         inputs: {
-            Operation: "base.enum:math.operation",
+            Operation: "enum:base.math.operation",
             A: "base.float[]",
             B: "base.float[]",
         },
@@ -2033,8 +2132,34 @@ function setupBasicGraphRegistry() {
             // Gracefully handle missing inputs by treating them as zeros
             const a = ins.A === undefined ? [] : asArray(ins.A);
             const b = ins.B === undefined ? [] : asArray(ins.B);
-            const len = Math.max(a.length, b.length);
             const op = Number(ins.Operation ?? 0) | 0;
+            // Unary ops on A
+            if (op === 8)
+                return { Result: a.map((x) => Math.round(Number(x))) };
+            if (op === 9)
+                return { Result: a.map((x) => Math.floor(Number(x))) };
+            if (op === 10)
+                return { Result: a.map((x) => Math.ceil(Number(x))) };
+            if (op === 11)
+                return { Result: a.map((x) => Math.abs(Number(x))) };
+            // Aggregate ops on A -> single-element array
+            if (op === 12)
+                return { Result: [a.reduce((s, x) => s + Number(x || 0), 0)] };
+            if (op === 13) {
+                const sum = a.reduce((s, x) => s + Number(x || 0), 0);
+                const avg = a.length ? sum / a.length : 0;
+                return { Result: [avg] };
+            }
+            if (op === 14)
+                return {
+                    Result: [a.length ? Math.min(...a.map((x) => Number(x))) : 0],
+                };
+            if (op === 15)
+                return {
+                    Result: [a.length ? Math.max(...a.map((x) => Number(x))) : 0],
+                };
+            // Binary ops A (broadcast) B
+            const len = Math.max(a.length, b.length);
             const ops = [
                 (x, y) => x + y,
                 (x, y) => x - y,
@@ -2059,7 +2184,7 @@ function setupBasicGraphRegistry() {
         id: "base.compare",
         categoryId: "compute",
         inputs: {
-            Operation: "base.enum:compare.operation",
+            Operation: "enum:base.compare.operation",
             A: "base.float[]",
             B: "base.float[]",
         },
@@ -2079,6 +2204,122 @@ function setupBasicGraphRegistry() {
             return { Result: a.map((x, i) => fn(Number(x), Number(b[i] ?? 0))) };
         },
     });
+    // Logic
+    registry.registerNode({
+        id: "base.logic",
+        categoryId: "compute",
+        inputs: { Operation: "base.string", A: "base.bool", B: "base.bool" },
+        outputs: { Result: "base.bool" },
+        impl: (ins) => {
+            const op = String(ins.Operation || "not").toLowerCase();
+            const a = !!ins.A;
+            const b = !!ins.B;
+            if (op === "not")
+                return { Result: !a };
+            if (op === "and")
+                return { Result: a && b };
+            if (op === "or")
+                return { Result: a || b };
+            return { Result: false };
+        },
+    });
+    // Strings
+    registry.registerNode({
+        id: "base.string.length",
+        categoryId: "compute",
+        inputs: { Text: "base.string" },
+        outputs: { Length: "base.float" },
+        impl: (ins) => ({
+            Length: String(ins.Text || "").length,
+        }),
+    });
+    registry.registerNode({
+        id: "base.string.op",
+        categoryId: "compute",
+        inputs: { Op: "base.string", Text: "base.string" },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const op = String(ins.Op || "trim").toLowerCase();
+            const t = String(ins.Text || "");
+            if (op === "lower")
+                return { Text: t.toLowerCase() };
+            if (op === "upper")
+                return { Text: t.toUpperCase() };
+            return { Text: t.trim() };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.split",
+        categoryId: "compute",
+        inputs: { Text: "base.string", Sep: "base.string" },
+        outputs: { Parts: "base.string[]" },
+        impl: (ins) => {
+            const t = String(ins.Text || "");
+            const sep = String(ins.Sep || ",");
+            return { Parts: t.split(sep) };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.join",
+        categoryId: "compute",
+        inputs: { Parts: "base.string[]", Sep: "base.string" },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const parts = Array.isArray(ins.Parts) ? ins.Parts.map(String) : [];
+            const sep = String(ins.Sep || "");
+            return { Text: parts.join(sep) };
+        },
+    });
+    registry.registerNode({
+        id: "base.string.replace",
+        categoryId: "compute",
+        inputs: {
+            Text: "base.string",
+            Search: "base.string",
+            Replace: "base.string",
+        },
+        outputs: { Text: "base.string" },
+        impl: (ins) => {
+            const t = String(ins.Text || "");
+            const s = String(ins.Search || "");
+            const r = String(ins.Replace || "");
+            return { Text: t.split(s).join(r) };
+        },
+    });
+    // Arrays (carried as base.object)
+    registry.registerNode({
+        id: "base.array.length",
+        categoryId: "compute",
+        inputs: { Items: "base.object" },
+        outputs: { Length: "base.float" },
+        impl: (ins) => ({
+            Length: Array.isArray(ins.Items) ? ins.Items.length : 0,
+        }),
+    });
+    registry.registerNode({
+        id: "base.array.slice",
+        categoryId: "compute",
+        inputs: { Items: "base.object", Start: "base.float", End: "base.float" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => {
+            const arr = Array.isArray(ins.Items) ? ins.Items : [];
+            const s = Math.trunc(Number(ins.Start ?? 0));
+            const e = Number.isFinite(Number(ins.End))
+                ? Math.trunc(Number(ins.End))
+                : undefined;
+            return { Result: arr.slice(s, e) };
+        },
+    });
+    // Select
+    registry.registerNode({
+        id: "base.select",
+        categoryId: "compute",
+        inputs: { Cond: "base.bool", Then: "base.object", Else: "base.object" },
+        outputs: { Result: "base.object" },
+        impl: (ins) => ({
+            Result: ins.Cond ? ins.Then : ins.Else,
+        }),
+    });
     // Combine XYZ
     registry.registerNode({
         id: "base.compareXYZ",
@@ -2217,6 +2458,195 @@ function setupBasicGraphRegistry() {
             },
         },
     });
+    // ------------------------- JSON/object utilities -------------------------
+    registry.registerNode({
+        id: "base.object.get",
+        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.object.set",
+        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.object.remove",
+        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.object.merge",
+        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.object.keys",
+        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.object.values",
+        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.object.patch",
+        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.array.concat",
+        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.array.flatten",
+        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.array.sortBy",
+        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) {