@virtualdisplay.io/client 3.6.0 → 3.7.0

package/dist/virtualdisplay.client.es.js

@@ -64,8 +64,7 @@ const EVENT_NAMES = {
   STATE_CHANGED: "state:changed",
   INITIAL_STATE_RECEIVED: "state:initial-received",
   // Snapshot flow
-  SNAPSHOT_MESSAGE: "snapshot:take",
-  SNAPSHOT_DEVELOPED: "snapshot:developed"
+  SNAPSHOT_MESSAGE: "snapshot:take"
 };
 const g = Object.freeze({
   debug: 0,
@@ -532,24 +531,6 @@ class Attribute {
   addValue(attributeValue) {
     this.values.set(attributeValue.value, attributeValue);
   }
-  /**
-   * Select a value - returns mutations needed for the change
-   * Pure function - no side effects
-   */
-  select(value) {
-    const newValue = this.values.get(value);
-    if (newValue === void 0) {
-      return [];
-    }
-    const currentValue = this.getCurrentValue();
-    if (currentValue === newValue) {
-      return [];
-    }
-    return [
-      ...currentValue?.getMutations().map((m2) => m2.inverse()) ?? [],
-      ...newValue.getMutations().map((m2) => m2.inverse())
-    ];
-  }
   getDefaultMutations() {
     return Array.from(this.values.values()).flatMap((value) => value.getMutations());
   }
@@ -572,6 +553,9 @@ class Attribute {
   get currentSelection() {
     return this.getCurrentValue()?.value;
   }
+  clear() {
+    this.values.clear();
+  }
 }
 const MUTATION_TYPES = {
   SHOW: "show",
@@ -6925,11 +6909,54 @@ class MappingValidator {
    * @throws {VirtualdisplayError} When mapping configuration is invalid
    */
   static validate(config) {
+    if (config === null || config === void 0) {
+      throw VirtualdisplayError.invalidMapping("Mapping configuration cannot be null or undefined");
+    }
+    if (this.containsDynamicValues(config)) {
+      this.validateBasicStructure(config);
+      return;
+    }
     if (!this.validateFn(config)) {
       const errors2 = this.validateFn.errors.map((err) => err.message).join(", ");
       throw VirtualdisplayError.invalidMapping(errors2);
     }
   }
+  /**
+   * Check if configuration contains dynamic values (functions)
+   */
+  static containsDynamicValues(config) {
+    if (config.attributes === void 0 || !Array.isArray(config.attributes)) {
+      return false;
+    }
+    return config.attributes.some((attr) => {
+      if (typeof attr.values === "function") {
+        return true;
+      }
+      if (Array.isArray(attr.values)) {
+        return attr.values.some((val) => typeof val.value === "function" || typeof val.nodeIds === "function" || typeof val.isSelected === "function");
+      }
+      return false;
+    });
+  }
+  /**
+   * Basic structure validation for dynamic mappings
+   */
+  static validateBasicStructure(config) {
+    if (config.attributes === void 0 || !Array.isArray(config.attributes)) {
+      throw VirtualdisplayError.invalidMapping("attributes must be an array");
+    }
+    if (config.attributes.length === 0) {
+      throw VirtualdisplayError.invalidMapping("attributes array must not be empty");
+    }
+    config.attributes.forEach((attr, index) => {
+      if (attr.name === void 0 || attr.name === "" || typeof attr.name !== "string") {
+        throw VirtualdisplayError.invalidMapping(`attribute at index ${index} must have a name`);
+      }
+      if (attr.values === void 0) {
+        throw VirtualdisplayError.invalidMapping(`attribute '${attr.name}' must have values`);
+      }
+    });
+  }
 }
 const MESSAGE_TYPES = {
   MUTATION: "mutation",
@@ -6968,6 +6995,12 @@ class AttributeService {
   attributes = /* @__PURE__ */ new Map();
   eventBus;
   isInitialized = false;
+  // Store original config for re-evaluation
+  mappingConfig = null;
+  // Store current selections
+  selections = /* @__PURE__ */ new Map();
+  // Store current visible nodes per attribute
+  currentState = /* @__PURE__ */ new Map();
   constructor(eventBus) {
     this.eventBus = eventBus;
     this.eventBus.on(EVENT_NAMES.STATE_CHANGED, (event) => {
@@ -6980,25 +7013,17 @@ class AttributeService {
    */
   loadMapping(config) {
     MappingValidator.validate(config);
+    this.mappingConfig = config;
     if (this.isInitialized) {
       this.attributes.clear();
+      this.selections.clear();
+      this.currentState.clear();
     }
-    const mutations = [];
-    config.attributes.forEach((attrConfig) => {
-      const attribute = new Attribute(attrConfig.name);
-      attrConfig.values.forEach((valueConfig) => {
-        const attributeValue = new AttributeValue(
-          valueConfig.value,
-          valueConfig.nodeIds,
-          valueConfig.isSelected
-        );
-        attribute.addValue(attributeValue);
-        logger.debug("Created attribute value", attributeValue);
-      });
-      this.attributes.set(attribute.name, attribute);
-      mutations.push(...attribute.getDefaultMutations());
-    });
+    this.attributes = this.evaluateMapping();
+    this.initializeSelections();
+    this.updateCurrentState();
     this.isInitialized = true;
+    const mutations = this.getInitialMutations();
     if (mutations.length > 0) {
       const mutationMessage = createMutationMessage(mutations);
       this.eventBus.emit(EVENT_NAMES.MUTATION_MESSAGE, {
@@ -7009,15 +7034,25 @@ class AttributeService {
   selectAttributeValue(attributeName, value) {
     const attribute = this.attributes.get(attributeName);
     if (attribute === void 0) {
+      logger.warn("Attribute not found", { attributeName });
       return;
     }
-    const mutations = attribute.select(value);
-    if (mutations.length === 0) {
+    if (!attribute.hasValue(value)) {
+      logger.warn("Value not found in attribute", { attributeName, value });
       return;
     }
-    this.eventBus.emit(EVENT_NAMES.MUTATION_MESSAGE, {
-      message: createMutationMessage(mutations)
-    });
+    this.selections.set(attributeName, value);
+    const oldState = new Map(this.currentState);
+    if (this.hasDynamicMapping()) {
+      this.attributes = this.evaluateMapping();
+    }
+    this.updateCurrentState();
+    const mutations = this.calculateMutations(oldState, this.currentState);
+    if (mutations.length > 0) {
+      this.eventBus.emit(EVENT_NAMES.MUTATION_MESSAGE, {
+        message: createMutationMessage(mutations)
+      });
+    }
   }
   getAttribute(name) {
     return this.attributes.get(name);
@@ -7032,26 +7067,157 @@ class AttributeService {
     if (!this.isInitialized) {
       return;
     }
-    nodes.forEach((node) => {
-      const attributeValue = this.getAttributeValueForNode(node.id);
-      if (attributeValue !== void 0) {
-        attributeValue.setSelected(node.isVisible);
-      }
-    });
-  }
-  getAttributeValueForNode(nodeId) {
+    const nodeVisibility = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      nodeVisibility.set(node.id, node.isVisible);
+    }
     for (const attribute of this.attributes.values()) {
-      const value = attribute.getAllValues().find((v) => v.hasNode(nodeId));
-      if (value !== void 0) {
-        return value;
+      for (const value of attribute.getAllValues()) {
+        const allNodesVisible = value.nodeList.every(
+          (nodeId) => nodeVisibility.get(nodeId) ?? false
+        );
+        value.setSelected(allNodesVisible);
       }
     }
-    return void 0;
   }
   clear() {
     this.attributes.clear();
+    this.selections.clear();
+    this.currentState.clear();
+    this.mappingConfig = null;
     this.isInitialized = false;
   }
+  /**
+   * Create context for dynamic evaluation
+   */
+  createContext() {
+    return {
+      getValue: (attributeName) => this.selections.get(attributeName),
+      getAllValues: () => new Map(this.selections)
+    };
+  }
+  /**
+   * Evaluate a property that might be static or dynamic
+   */
+  evaluateProperty(prop, context) {
+    return typeof prop === "function" ? prop(context) : prop;
+  }
+  /**
+   * Evaluate the entire mapping with current context
+   */
+  evaluateMapping() {
+    if (this.mappingConfig === null) {
+      return /* @__PURE__ */ new Map();
+    }
+    const context = this.createContext();
+    const evaluatedAttributes = /* @__PURE__ */ new Map();
+    for (const attrConfig of this.mappingConfig.attributes) {
+      const attribute = this.createAttributeFromConfig(attrConfig, context);
+      evaluatedAttributes.set(attribute.name, attribute);
+    }
+    return evaluatedAttributes;
+  }
+  /**
+   * Create a single attribute from configuration
+   */
+  createAttributeFromConfig(attrConfig, context) {
+    const attribute = new Attribute(attrConfig.name);
+    const values = this.evaluateProperty(attrConfig.values, context);
+    for (const valueConfig of values) {
+      const value = this.evaluateProperty(valueConfig.value, context);
+      const nodeIds = this.evaluateProperty(valueConfig.nodeIds, context);
+      const isSelected = this.evaluateProperty(valueConfig.isSelected ?? false, context);
+      const currentSelection = this.selections.get(attrConfig.name);
+      const shouldBeSelected = currentSelection !== void 0 ? currentSelection === value : isSelected;
+      const attributeValue = new AttributeValue(value, nodeIds, shouldBeSelected);
+      attribute.addValue(attributeValue);
+      logger.debug("Created attribute value", attributeValue);
+    }
+    return attribute;
+  }
+  /**
+   * Initialize selections from default values
+   */
+  initializeSelections() {
+    for (const [name, attribute] of this.attributes) {
+      const selectedValue = attribute.getCurrentValue();
+      if (selectedValue !== void 0) {
+        this.selections.set(name, selectedValue.value);
+      }
+    }
+  }
+  /**
+   * Check if the mapping configuration contains dynamic elements
+   */
+  hasDynamicMapping() {
+    if (this.mappingConfig === null) {
+      return false;
+    }
+    return MappingValidator.containsDynamicValues(this.mappingConfig);
+  }
+  /**
+   * Update current state map with visible nodes per attribute
+   */
+  updateCurrentState() {
+    this.currentState.clear();
+    for (const [name, attribute] of this.attributes) {
+      const visibleNodes = this.getVisibleNodesForAttribute(name, attribute);
+      this.currentState.set(name, visibleNodes);
+    }
+  }
+  getVisibleNodesForAttribute(name, attribute) {
+    const visibleNodes = /* @__PURE__ */ new Set();
+    const selectedValueName = this.selections.get(name);
+    if (selectedValueName === void 0) {
+      return visibleNodes;
+    }
+    const selectedValue = attribute.getValue(selectedValueName);
+    if (selectedValue !== void 0) {
+      selectedValue.nodeList.forEach((nodeId) => visibleNodes.add(nodeId));
+    }
+    return visibleNodes;
+  }
+  /**
+   * Get initial mutations for default selections
+   */
+  getInitialMutations() {
+    const mutations = [];
+    for (const attribute of this.attributes.values()) {
+      mutations.push(...attribute.getDefaultMutations());
+    }
+    return mutations;
+  }
+  /**
+   * Calculate mutations by comparing old and new state
+   */
+  calculateMutations(oldState, newState) {
+    const mutations = [];
+    const allNodeIds = /* @__PURE__ */ new Set();
+    oldState.forEach((nodes) => nodes.forEach((id2) => allNodeIds.add(id2)));
+    newState.forEach((nodes) => nodes.forEach((id2) => allNodeIds.add(id2)));
+    for (const nodeId of allNodeIds) {
+      const wasVisible = this.isNodeVisible(nodeId, oldState);
+      const isVisible = this.isNodeVisible(nodeId, newState);
+      if (wasVisible && !isVisible) {
+        mutations.push(Mutation.hide(nodeId));
+      }
+      if (!wasVisible && isVisible) {
+        mutations.push(Mutation.show(nodeId));
+      }
+    }
+    return mutations;
+  }
+  /**
+   * Check if a node is visible in the given state
+   */
+  isNodeVisible(nodeId, state) {
+    for (const nodes of state.values()) {
+      if (nodes.has(nodeId)) {
+        return true;
+      }
+    }
+    return false;
+  }
 }
 class Camera {
   constructor(eventBus) {