spytial-core 1.4.10 → 1.4.11-beta.1

package/dist/browser/spytial-core-complete.global.js

@@ -94528,7 +94528,6 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
       init_layoutinstance();
       init_layoutspec();
       exports.StructuredInputGraph = class extends WebColaCnDGraph {
-        // Default to 2 positions
         constructor(dataInstance) {
           super();
           this.evaluator = null;
@@ -94537,6 +94536,16 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
           this.controlsContainer = null;
           this.customTypes = /* @__PURE__ */ new Set();
           this.relationAtomPositions = ["", ""];
+          // Default to 2 positions
+          this.currentConstraintError = null;
+          // Track current constraint validation error
+          // Track event listeners to prevent duplicates
+          this.dataInstanceEventHandlers = {
+            atomAdded: null,
+            atomRemoved: null,
+            relationTupleAdded: null,
+            relationTupleRemoved: null
+          };
           const instance = dataInstance || new exports.JSONDataInstance({
             atoms: [],
             relations: []
@@ -95217,6 +95226,7 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
         }
         /**
          * Enforce constraints and regenerate layout
+         * This method validates constraints on every data update and reports UNSAT cores
          */
         async enforceConstraintsAndRegenerate() {
           console.log("\u{1F504} enforceConstraintsAndRegenerate() called");
@@ -95240,15 +95250,37 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
             const projections = {};
             const layoutResult = this.layoutInstance.generateLayout(this.dataInstance, projections);
             if (layoutResult.error) {
-              console.warn("\u26A0\uFE0F Constraint validation error:", layoutResult.error);
+              console.warn("\u26A0\uFE0F Constraint validation error detected:", layoutResult.error);
+              this.currentConstraintError = layoutResult.error;
+              this.dispatchEvent(new CustomEvent("constraint-error", {
+                detail: {
+                  error: layoutResult.error,
+                  layout: layoutResult.layout
+                },
+                bubbles: true
+              }));
+              console.log("\u{1F4E4} Dispatched constraint-error event with UNSAT core information");
             } else {
-              console.log("\u2705 Layout generated successfully");
+              console.log("\u2705 Layout generated successfully - all constraints satisfied");
+              if (this.currentConstraintError !== null) {
+                console.log("\u{1F9F9} Clearing previous constraint error - constraints now satisfied");
+                this.currentConstraintError = null;
+                this.dispatchEvent(new CustomEvent("constraints-satisfied", {
+                  detail: { layout: layoutResult.layout },
+                  bubbles: true
+                }));
+                console.log("\u{1F4E4} Dispatched constraints-satisfied event");
+              }
             }
             console.log("\u{1F3A8} Rendering layout...");
             await this.renderLayout(layoutResult.layout);
             console.log("\u2705 Constraints enforced and layout regenerated successfully");
           } catch (error) {
             console.error("\u274C Failed to enforce constraints and regenerate layout:", error);
+            this.dispatchEvent(new CustomEvent("layout-generation-error", {
+              detail: { error },
+              bubbles: true
+            }));
           }
         }
         /**
@@ -95507,24 +95539,66 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
             console.error("\u274C Failed to export data:", error);
           }
         }
+        /**
+         * Common handler for data changes that updates UI components
+         * @param includeAtomPositions - Whether to update atom position selectors (needed for atom changes)
+         */
+        handleDataChangeUIUpdate(includeAtomPositions = false) {
+          this.refreshTypesFromDataInstance();
+          this.updateDeletionSelects();
+          if (includeAtomPositions) {
+            this.updateAtomPositions();
+          }
+        }
+        /**
+         * Common handler for data deletions that updates UI and triggers constraint validation
+         * @param includeAtomPositions - Whether to update atom position selectors (needed for atom deletions)
+         */
+        async handleDataDeletionWithValidation(includeAtomPositions = false) {
+          this.handleDataChangeUIUpdate(includeAtomPositions);
+          await this.enforceConstraintsAndRegenerate();
+        }
         /**
          * Set the data instance for this graph
          */
         setDataInstance(instance) {
           console.log("\u{1F504} Setting new data instance");
+          if (this.dataInstance) {
+            if (this.dataInstanceEventHandlers.atomAdded) {
+              this.dataInstance.removeEventListener("atomAdded", this.dataInstanceEventHandlers.atomAdded);
+            }
+            if (this.dataInstanceEventHandlers.atomRemoved) {
+              this.dataInstance.removeEventListener("atomRemoved", this.dataInstanceEventHandlers.atomRemoved);
+            }
+            if (this.dataInstanceEventHandlers.relationTupleAdded) {
+              this.dataInstance.removeEventListener("relationTupleAdded", this.dataInstanceEventHandlers.relationTupleAdded);
+            }
+            if (this.dataInstanceEventHandlers.relationTupleRemoved) {
+              this.dataInstance.removeEventListener("relationTupleRemoved", this.dataInstanceEventHandlers.relationTupleRemoved);
+            }
+          }
           this.dataInstance = instance;
           this.refreshTypesFromDataInstance();
-          instance.addEventListener("atomAdded", () => {
+          this.dataInstanceEventHandlers.atomAdded = () => {
             console.log("\u{1F4CD} Atom added to instance - updating UI");
-            this.refreshTypesFromDataInstance();
-            this.updateDeletionSelects();
-            this.updateAtomPositions();
-          });
-          instance.addEventListener("relationTupleAdded", () => {
+            this.handleDataChangeUIUpdate(true);
+          };
+          this.dataInstanceEventHandlers.relationTupleAdded = () => {
             console.log("\u{1F517} Relation added to instance - updating UI");
-            this.refreshTypesFromDataInstance();
-            this.updateDeletionSelects();
-          });
+            this.handleDataChangeUIUpdate(false);
+          };
+          this.dataInstanceEventHandlers.atomRemoved = async () => {
+            console.log("\u{1F5D1}\uFE0F Atom removed from instance - updating UI and re-validating constraints");
+            await this.handleDataDeletionWithValidation(true);
+          };
+          this.dataInstanceEventHandlers.relationTupleRemoved = async () => {
+            console.log("\u{1F5D1}\uFE0F Relation tuple removed from instance - updating UI and re-validating constraints");
+            await this.handleDataDeletionWithValidation(false);
+          };
+          instance.addEventListener("atomAdded", this.dataInstanceEventHandlers.atomAdded);
+          instance.addEventListener("relationTupleAdded", this.dataInstanceEventHandlers.relationTupleAdded);
+          instance.addEventListener("atomRemoved", this.dataInstanceEventHandlers.atomRemoved);
+          instance.addEventListener("relationTupleRemoved", this.dataInstanceEventHandlers.relationTupleRemoved);
           this.updateDeletionSelects();
           this.updateAtomPositions();
           console.log("\u2705 Data instance set successfully");
@@ -95583,18 +95657,8 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
               console.warn(`\u26A0\uFE0F Atom ${atomId} not found`);
               return;
             }
-            const remainingAtoms = atoms.filter((atom) => atom.id !== atomId);
-            const relations = this.dataInstance.getRelations().filter(
-              (rel) => !rel.tuples.some((tuple) => tuple.atoms.includes(atomId))
-            );
-            const newInstance = new exports.JSONDataInstance({
-              atoms: remainingAtoms,
-              relations,
-              types: []
-            });
-            this.setDataInstance(newInstance);
+            this.dataInstance.removeAtom(atomId);
             console.log(`\u2705 Atom removed from data instance: ${atomToDelete.label} (${atomToDelete.id})`);
-            await this.enforceConstraintsAndRegenerate();
             console.log(`\u{1F389} Atom deletion completed: ${atomToDelete.label} (${atomToDelete.id})`);
             this.dispatchEvent(new CustomEvent("atom-deleted", {
               detail: { atom: atomToDelete }
@@ -95634,9 +95698,7 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
             console.log(`\u{1F5D1}\uFE0F Found tuple in relation "${relationId}": ${targetTuple.atoms.join(" \u2192 ")}`);
             this.dataInstance.removeRelationTuple(relationId, targetTuple);
             console.log(`\u2705 Relation tuple removed from data instance: ${relationId}: ${targetTuple.atoms.join(" \u2192 ")}`);
-            await this.enforceConstraintsAndRegenerate();
             console.log(`\u{1F389} Relation tuple deletion completed: ${relationId}: ${targetTuple.atoms.join(" \u2192 ")}`);
-            this.updateDeletionSelects();
             this.dispatchEvent(new CustomEvent("relation-tuple-deleted", {
               detail: { relationId, tuple: targetTuple }
             }));
@@ -95672,6 +95734,19 @@ VVbdfjptxz|~\x80\x82\x84\xA6\xA8W\b
         getDataInstance() {
           return this.dataInstance;
         }
+        /**
+         * Get the current constraint error (if any)
+         * Returns null if all constraints are currently satisfied
+         */
+        getCurrentConstraintError() {
+          return this.currentConstraintError;
+        }
+        /**
+         * Check if there are currently unsatisfied constraints
+         */
+        hasConstraintErrors() {
+          return this.currentConstraintError !== null;
+        }
         /**
          * Set the CnD specification
          */