@bian-womp/spark-graph 0.1.4 → 0.1.6

package/lib/cjs/index.cjs

@@ -19,11 +19,11 @@ class Registry {
     constructor() {
         this.types = new Map();
         this.nodes = new Map();
+        this.enums = new Map();
         this.categories = new CategoryRegistry();
         this.serializers = new Map();
         this.coercions = new Map();
         this.asyncCoercions = new Map();
-        this.enums = new Map();
     }
     registerType(desc, opts) {
         this.types.set(desc.id, desc);
@@ -124,33 +124,37 @@ class Registry {
         return out;
     }
     // Enum support
-    registerEnum(enumTypeId, options, labelType, valueType) {
+    registerEnum(desc) {
+        const { id, displayName, options, opts } = desc;
+        const labelType = opts?.labelType ?? "base.string";
+        const valueType = opts?.valueType ?? "base.float";
         const valueToLabel = new Map();
         const labelToValue = new Map();
         for (const { value, label } of options) {
             valueToLabel.set(value, label);
             labelToValue.set(label.toLowerCase(), value);
         }
-        this.enums.set(enumTypeId, {
+        this.enums.set(id, {
             options,
             valueToLabel,
             labelToValue,
         });
         // Register type descriptor and serializer for enum (stored as number)
         this.registerType({
-            id: enumTypeId,
+            id,
+            displayName,
             validate: (v) => typeof v === "number" && valueToLabel.has(Number(v)),
-        });
-        this.registerSerializer(enumTypeId, {
+        }, opts);
+        this.registerSerializer(id, {
             serialize: (v) => v,
             deserialize: (d) => Number(d),
         });
         // Coercions: string -> enum (by label), float -> enum (by numeric value), enum -> string (label)
-        this.registerCoercion(labelType, enumTypeId, (value) => {
+        this.registerCoercion(labelType, id, (value) => {
             const s = String(value ?? "")
                 .trim()
                 .toLowerCase();
-            const rec = this.enums.get(enumTypeId);
+            const rec = this.enums.get(id);
             if (!rec)
                 return value;
             if (rec.labelToValue.has(s))
@@ -160,33 +164,24 @@ class Registry {
                 return asNum;
             return Array.from(rec.valueToLabel.keys())[0] ?? 0;
         });
-        this.registerCoercion(valueType, enumTypeId, (value) => {
+        this.registerCoercion(valueType, id, (value) => {
             const n = Number(value);
-            const rec = this.enums.get(enumTypeId);
+            const rec = this.enums.get(id);
             if (!rec)
                 return value;
             return rec.valueToLabel.has(n)
                 ? n
                 : Array.from(rec.valueToLabel.keys())[0] ?? 0;
         });
-        this.registerCoercion(enumTypeId, labelType, (value) => {
+        this.registerCoercion(id, labelType, (value) => {
             const n = Number(value);
-            const rec = this.enums.get(enumTypeId);
+            const rec = this.enums.get(id);
             if (!rec)
                 return String(value);
             return rec.valueToLabel.get(n) ?? String(n);
         });
         return this;
     }
-    getEnumOptions(enumTypeId) {
-        return this.enums.get(enumTypeId)?.options ?? [];
-    }
-    getEnumLabel(enumTypeId, value) {
-        return this.enums.get(enumTypeId)?.valueToLabel.get(value);
-    }
-    getEnumValue(enumTypeId, label) {
-        return this.enums.get(enumTypeId)?.labelToValue.get(label.toLowerCase());
-    }
 }
 
 class GraphRuntime {
@@ -1436,25 +1431,31 @@ function setupBasicGraphRegistry() {
         impl: (ins) => ({ Text: String(ins.Value) }),
     });
     // Enums: Math Operation
-    registry.registerEnum("base.enum:math.operation", [
-        { 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" },
-    ], "base.string", "base.float");
+    registry.registerEnum({
+        id: "base.enum: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" },
+        ],
+    });
     // Enums: Compare Operation
-    registry.registerEnum("base.enum:compare.operation", [
-        { value: 0, label: "LessThan" },
-        { value: 1, label: "LessThanOrEqual" },
-        { value: 2, label: "GreaterThan" },
-        { value: 3, label: "GreaterThanOrEqual" },
-        { value: 4, label: "Equal" },
-        { value: 5, label: "NotEqual" },
-    ], "base.string", "base.float");
+    registry.registerEnum({
+        id: "base.enum: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" },
+        ],
+    });
     // Clamp
     registry.registerNode({
         id: "base.clamp",