@bian-womp/spark-graph 0.1.25 → 0.1.27

package/lib/cjs/index.cjs

@@ -1780,6 +1780,22 @@ const broadcast = (a, b) => {
     const len = Math.max(aa.length, bb.length);
     return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
 };
+const asBoolArray = (v) => Array.isArray(v) ? v.map((x) => Boolean(x)) : [Boolean(v)];
+const broadcastBool = (a, b) => {
+    const aa = asBoolArray(a);
+    const bb = asBoolArray(b);
+    if (aa.length === bb.length)
+        return [aa, bb];
+    if (aa.length === 1)
+        return [new Array(bb.length).fill(aa[0]), bb];
+    if (bb.length === 1)
+        return [aa, new Array(aa.length).fill(bb[0])];
+    const len = Math.max(aa.length, bb.length);
+    return [
+        new Array(len).fill(aa[0] ?? false),
+        new Array(len).fill(bb[0] ?? false),
+    ];
+};
 const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
 const lerp = (a, b, t) => a + (b - a) * t;
 const lcg = (seed) => {
@@ -1971,50 +1987,70 @@ function setupBasicGraphRegistry() {
             return undefined;
         }
     });
+    const BaseMathOperation = {
+        Add: 0,
+        Subtract: 1,
+        Multiply: 2,
+        Divide: 3,
+        Min: 4,
+        Max: 5,
+        Modulo: 6,
+        Power: 7,
+        Round: 8,
+        Floor: 9,
+        Ceil: 10,
+        Abs: 11,
+        Sum: 12,
+        Avg: 13,
+        MinAll: 14,
+        MaxAll: 15,
+        Sin: 16,
+        Cos: 17,
+        Tan: 18,
+        Asin: 19,
+        Acos: 20,
+        Atan: 21,
+        Sqrt: 22,
+        Exp: 23,
+        Log: 24,
+    };
     // Enums: Math Operation
     registry.registerEnum({
         id: "enum:base.math.operation",
-        options: [
-            { value: 0, label: "Add" },
-            { value: 1, label: "Subtract" },
-            { value: 2, label: "Multiply" },
-            { value: 3, label: "Divide" },
-            { value: 4, label: "Min" },
-            { 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" },
-            // Trig and other unary functions on A
-            { value: 16, label: "Sin" },
-            { value: 17, label: "Cos" },
-            { value: 18, label: "Tan" },
-            { value: 19, label: "ASin" },
-            { value: 20, label: "ACos" },
-            { value: 21, label: "ATan" },
-            { value: 22, label: "Sqrt" },
-            { value: 23, label: "Exp" },
-            { value: 24, label: "Log" },
-        ],
+        options: Object.entries(BaseMathOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
     });
+    const BaseCompareOperation = {
+        LessThan: 0,
+        LessThanOrEqual: 1,
+        GreaterThan: 2,
+        GreaterThanOrEqual: 3,
+        Equal: 4,
+        NotEqual: 5,
+    };
     // Enums: Compare Operation
     registry.registerEnum({
         id: "enum:base.compare.operation",
-        options: [
-            { value: 0, label: "LessThan" },
-            { value: 1, label: "LessThanOrEqual" },
-            { value: 2, label: "GreaterThan" },
-            { value: 3, label: "GreaterThanOrEqual" },
-            { value: 4, label: "Equal" },
-            { value: 5, label: "NotEqual" },
-        ],
+        options: Object.entries(BaseCompareOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
+    });
+    const BaseLogicOperation = {
+        Not: 0,
+        And: 1,
+        Or: 2,
+        Xor: 3,
+    };
+    // Enums: Logic Operation
+    registry.registerEnum({
+        id: "enum:base.logic.operation",
+        options: Object.entries(BaseLogicOperation).map(([label, value]) => ({
+            value,
+            label,
+        })),
     });
     // Number
     registry.registerNode({
@@ -2139,53 +2175,49 @@ function setupBasicGraphRegistry() {
         // Registry-level defaults: Add by default, A=[1], B=[1]
         inputDefaults: { Operation: 0, A: [1], B: [1] },
         impl: (ins) => {
-            // 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 a = asArray(ins.A ?? []);
+            const b = asArray(ins.B ?? []);
             const op = Number(ins.Operation ?? 0) | 0;
-            // Unary ops on A
-            const unary = {
-                8: (x) => Math.round(x),
-                9: (x) => Math.floor(x),
-                10: (x) => Math.ceil(x),
-                11: (x) => Math.abs(x),
-                16: (x) => Math.sin(x),
-                17: (x) => Math.cos(x),
-                18: (x) => Math.tan(x),
-                19: (x) => Math.asin(x),
-                20: (x) => Math.acos(x),
-                21: (x) => Math.atan(x),
-                22: (x) => Math.sqrt(x),
-                23: (x) => Math.exp(x),
-                24: (x) => Math.log(x),
+            const unaryByOp = {
+                [BaseMathOperation.Round]: (x) => Math.round(x),
+                [BaseMathOperation.Floor]: (x) => Math.floor(x),
+                [BaseMathOperation.Ceil]: (x) => Math.ceil(x),
+                [BaseMathOperation.Abs]: (x) => Math.abs(x),
+                [BaseMathOperation.Sin]: (x) => Math.sin(x),
+                [BaseMathOperation.Cos]: (x) => Math.cos(x),
+                [BaseMathOperation.Tan]: (x) => Math.tan(x),
+                [BaseMathOperation.Asin]: (x) => Math.asin(x),
+                [BaseMathOperation.Acos]: (x) => Math.acos(x),
+                [BaseMathOperation.Atan]: (x) => Math.atan(x),
+                [BaseMathOperation.Sqrt]: (x) => Math.sqrt(x),
+                [BaseMathOperation.Exp]: (x) => Math.exp(x),
+                [BaseMathOperation.Log]: (x) => Math.log(x),
             };
-            if (op in unary)
-                return { Result: a.map((x) => unary[op](Number(x))) };
-            // Aggregate ops on A -> single-element array
-            const aggregates = {
-                12: (arr) => arr.reduce((s, x) => s + Number(x || 0), 0),
-                13: (arr) => {
+            if (unaryByOp[op])
+                return { Result: a.map((x) => unaryByOp[op](Number(x))) };
+            const aggregateByOp = {
+                [BaseMathOperation.Sum]: (arr) => arr.reduce((s, x) => s + Number(x || 0), 0),
+                [BaseMathOperation.Avg]: (arr) => {
                     const sum = arr.reduce((s, x) => s + Number(x || 0), 0);
                     return arr.length ? sum / arr.length : 0;
                 },
-                14: (arr) => (arr.length ? Math.min(...arr.map((x) => Number(x))) : 0),
-                15: (arr) => (arr.length ? Math.max(...arr.map((x) => Number(x))) : 0),
+                [BaseMathOperation.MinAll]: (arr) => arr.length ? Math.min(...arr.map((x) => Number(x))) : 0,
+                [BaseMathOperation.MaxAll]: (arr) => arr.length ? Math.max(...arr.map((x) => Number(x))) : 0,
             };
-            if (op in aggregates)
-                return { Result: [aggregates[op](a)] };
-            // Binary ops A (broadcast) B
+            if (aggregateByOp[op] !== undefined)
+                return { Result: [aggregateByOp[op](a)] };
+            const binaryByOp = {
+                [BaseMathOperation.Add]: (x, y) => x + y,
+                [BaseMathOperation.Subtract]: (x, y) => x - y,
+                [BaseMathOperation.Multiply]: (x, y) => x * y,
+                [BaseMathOperation.Divide]: (x, y) => x / (y || 1),
+                [BaseMathOperation.Min]: (x, y) => Math.min(x, y),
+                [BaseMathOperation.Max]: (x, y) => Math.max(x, y),
+                [BaseMathOperation.Modulo]: (x, y) => (y ? x % y : 0),
+                [BaseMathOperation.Power]: (x, y) => Math.pow(x, y),
+            };
+            const fn = binaryByOp[op] || binaryByOp[BaseMathOperation.Add];
             const len = Math.max(a.length, b.length);
-            const ops = [
-                (x, y) => x + y,
-                (x, y) => x - y,
-                (x, y) => x * y,
-                (x, y) => x / (y || 1),
-                (x, y) => Math.min(x, y),
-                (x, y) => Math.max(x, y),
-                (x, y) => (y ? x % y : 0),
-                (x, y) => Math.pow(x, y),
-            ];
-            const fn = ops[op] ?? ops[0];
             const out = new Array(len).fill(0).map((_, i) => {
                 const ax = a.length === 1 && len > 1 ? a[0] : a[i] ?? 0;
                 const bx = b.length === 1 && len > 1 ? b[0] : b[i] ?? 0;
@@ -2206,16 +2238,16 @@ function setupBasicGraphRegistry() {
         outputs: { Result: "base.bool[]" },
         impl: (ins) => {
             const [a, b] = broadcast(ins.A, ins.B);
-            const op = Number(ins.Operation ?? 4) | 0; // default Equal
-            const ops = [
-                (x, y) => x < y,
-                (x, y) => x <= y,
-                (x, y) => x > y,
-                (x, y) => x >= y,
-                (x, y) => x === y,
-                (x, y) => x !== y,
-            ];
-            const fn = ops[op] ?? ops[4];
+            const op = Number(ins.Operation ?? BaseCompareOperation.Equal) | 0;
+            const compareByOp = {
+                [BaseCompareOperation.LessThan]: (x, y) => x < y,
+                [BaseCompareOperation.LessThanOrEqual]: (x, y) => x <= y,
+                [BaseCompareOperation.GreaterThan]: (x, y) => x > y,
+                [BaseCompareOperation.GreaterThanOrEqual]: (x, y) => x >= y,
+                [BaseCompareOperation.Equal]: (x, y) => x === y,
+                [BaseCompareOperation.NotEqual]: (x, y) => x !== y,
+            };
+            const fn = compareByOp[op] || compareByOp[BaseCompareOperation.Equal];
             return { Result: a.map((x, i) => fn(Number(x), Number(b[i] ?? 0))) };
         },
     });
@@ -2223,19 +2255,29 @@ function setupBasicGraphRegistry() {
     registry.registerNode({
         id: "base.logic",
         categoryId: "compute",
-        inputs: { Operation: "base.string", A: "base.bool", B: "base.bool" },
-        outputs: { Result: "base.bool" },
+        inputs: {
+            Operation: "enum:base.logic.operation",
+            A: "base.bool[]",
+            B: "base.bool[]",
+        },
+        outputs: { Result: "base.bool[]" },
+        inputDefaults: { Operation: BaseLogicOperation.Not },
         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 };
+            const op = Number(ins.Operation ?? BaseLogicOperation.Not) | 0;
+            if (op === BaseLogicOperation.Not) {
+                const a = asBoolArray(ins.A ?? []);
+                return { Result: a.map((x) => !x) };
+            }
+            const [a, b] = broadcastBool(ins.A ?? [], ins.B ?? []);
+            const logicByOp = {
+                [BaseLogicOperation.And]: (x, y) => x && y,
+                [BaseLogicOperation.Or]: (x, y) => x || y,
+                [BaseLogicOperation.Xor]: (x, y) => Boolean(x ? !y : y),
+            };
+            const fn = logicByOp[op] || logicByOp[BaseLogicOperation.And];
+            return {
+                Result: a.map((x, i) => fn(Boolean(x), Boolean(b[i] ?? false))),
+            };
         },
     });
     // Strings
@@ -2494,7 +2536,7 @@ function setupBasicGraphRegistry() {
         inputs: {
             Object: "base.object",
             Pointers: "base.string[]",
-            NewValues: "base.string[]",
+            NewValues: "base.object",
         },
         outputs: { Result: "base.object" },
         impl: (ins) => {