@jinntec/fore 2.7.2 → 2.8.0

package/src/fx-instance.js

@@ -163,10 +163,10 @@ export class FxInstance extends HTMLElement {
     // Note: use the getter here: it might provide us with stubbed data if anything async is racing,
     // such as an @src attribute
     const instanceData = this.getInstanceData();
-    if (this.type === 'xml') {
+    if (this.type === 'xml'  || this.type === 'html') {
       return instanceData.firstElementChild;
     }
-    return instanceData;
+    return this.instanceData;
   }
 
   /**

package/src/fx-submission.js

@@ -377,6 +377,24 @@ export class FxSubmission extends ForeElementMixin {
     const targetInstance = this._getTargetInstance();
 
     if (this.replace === 'instance') {
+      const targetInstance = this._getTargetInstance();
+
+      // ### contentType handling
+
+      if (contentType.includes('html')) {
+        let effectiveData;
+        if (data.nodeType) {
+          effectiveData = data;
+        }
+        // ## try parsing
+        try {
+          effectiveData = new DOMParser().parseFromString(data, 'text/html');
+        } catch {
+          Fore.dispatch(this, 'error', { message: 'could not parse data as HTML' });
+        }
+
+        targetInstance.instanceData = effectiveData;
+      }
       if (targetInstance) {
         if (this.targetref) {
           const [theTarget] = evaluateXPath(

package/src/modelitem.js

@@ -71,13 +71,13 @@ export class ModelItem {
     if (!this.node) return;
     const oldVal = this.value;
 
-    if (newVal?.nodeType === Node.DOCUMENT_NODE) {
+    if (newVal?.nodeType && newVal.nodeType === Node.DOCUMENT_NODE) {
       this.node.replaceWith(newVal.firstElementChild);
-      this.node = newVal.firstElementChild;
-    } else if (newVal?.nodeType === Node.ELEMENT_NODE) {
+      // this.node.appendChild(newVal.firstElementChild);
+    } else if (newVal?.nodeType && newVal.nodeType === Node.ELEMENT_NODE) {
       this.node.replaceWith(newVal);
-      this.node = newVal;
-    } else if (this.node.nodeType === Node.ATTRIBUTE_NODE) {
+      // this.node.appendChild(newVal);
+    } else if (newVal?.nodeType && this.node.nodeType === Node.ATTRIBUTE_NODE) {
       this.node.nodeValue = newVal;
     } else {
       this.node.textContent = newVal;

package/src/tools/deprecation.md

@@ -0,0 +1 @@
+This package is deprecated and no longer maintained or included in index.js

package/src/tools/fx-action-log.js

@@ -1,4 +1,4 @@
-import { XPathUtil } from '../xpath-util';
+import { XPathUtil } from '../xpath-util.js';
 import './fx-log-item.js';
 import { FxLogSettings } from './fx-log-settings.js';
 import { getDocPath, getPath } from '../xpath-path.js';
@@ -521,7 +521,7 @@ export class FxActionLog extends HTMLElement {
    */
   _logDetails(e) {
     const eventType = e.type;
-    const path = XPathUtil.getPath(e.target, '');
+    const path = getPath(e.target, '');
     // console.log('>>>> _logDetails', path);
     const cut = path.substring(path.indexOf('/fx-fore'), path.length);
     const xpath = `/${cut}`;

package/src/ui/abstract-control.js

@@ -286,6 +286,10 @@ export default class AbstractControl extends UIElement {
   }
 
   _toggleValid(valid) {
+    // Used by required handling (and potentially other callers).
+    // It must also fire validity events and sync aria-invalid.
+    const wasInvalid = this.hasAttribute('invalid');
+
     if (valid) {
       this.removeAttribute('invalid');
       this.setAttribute('valid', '');
@@ -293,6 +297,25 @@ export default class AbstractControl extends UIElement {
       this.removeAttribute('valid');
       this.setAttribute('invalid', '');
     }
+    this._syncAriaInvalid();
+
+    const isInvalid = this.hasAttribute('invalid');
+    // Only dispatch when the state actually changed
+    if (wasInvalid !== isInvalid) {
+      this._dispatchEvent(isInvalid ? 'invalid' : 'valid');
+    }
+  }
+
+  _syncAriaInvalid() {
+    // Keep widget aria-invalid in sync with the *control* state, regardless of
+    // whether invalidity comes from constraint, required emptiness, etc.
+    try {
+      const w = this.getWidget?.() || this.widget;
+      if (!w) return;
+      w.setAttribute('aria-invalid', this.hasAttribute('invalid') ? 'true' : 'false');
+    } catch (e) {
+      // ignore: widget might not exist yet
+    }
   }
 
   handleReadonly() {
@@ -321,8 +344,8 @@ export default class AbstractControl extends UIElement {
         // if (alert) alert.style.display = 'none';
         this._dispatchEvent('valid');
         this.setAttribute('valid', '');
-        this.getWidget().setAttribute('aria-invalid', 'false');
         this.removeAttribute('invalid');
+        this.getWidget().setAttribute('aria-invalid', 'false');
       } else {
         this.setAttribute('invalid', '');
         this.getWidget().setAttribute('aria-invalid', 'true');
@@ -352,31 +375,41 @@ export default class AbstractControl extends UIElement {
         this._dispatchEvent('invalid');
       }
     }
+
+    // Ensure aria-invalid matches the current control state even if
+    // we didn't enter the state-change branch above.
+    this._syncAriaInvalid();
+
   }
 
   handleRelevant() {
-    // console.log('mip valid', this.modelItem.enabled);
+    // IMPORTANT: don't clear relevant/nonrelevant BEFORE comparing states.
+    // Otherwise isEnabled() (based on attributes) always reads as "enabled"
+    // and we can never detect a transition back to relevant.
     const item = this.modelItem.node;
-    this.removeAttribute('relevant');
-    this.removeAttribute('nonrelevant');
+
+    const wasEnabled = this.isEnabled();
+
+    // Determine new enabled state
+    let newEnabled = !!this.modelItem.relevant;
+
+    // If a nodeset resolves to an empty array, treat the control as nonrelevant
     if (Array.isArray(item) && item.length === 0) {
-      this._dispatchEvent('nonrelevant');
-      this.setAttribute('nonrelevant', '');
-      // this.style.display = 'none';
-      return;
+      newEnabled = false;
     }
-    if (this.isEnabled() !== this.modelItem.relevant) {
-      if (this.modelItem.relevant) {
-        this._dispatchEvent('relevant');
-        // this._fadeIn(this, this.display);
+
+    // Apply attributes
+    if (newEnabled) {
         this.setAttribute('relevant', '');
-        // this.style.display = this.display;
+      this.removeAttribute('nonrelevant');
       } else {
-        this._dispatchEvent('nonrelevant');
-        // this._fadeOut(this);
         this.setAttribute('nonrelevant', '');
-        // this.style.display = 'none';
+      this.removeAttribute('relevant');
       }
+
+    // Dispatch only on actual change
+    if (wasEnabled !== newEnabled) {
+      this._dispatchEvent(newEnabled ? 'relevant' : 'nonrelevant');
     }
   }
 

package/src/xpath-util.js

@@ -1,5 +1,4 @@
 import * as fx from 'fontoxpath';
-import { createNamespaceResolver } from './xpath-evaluation';
 
 export class XPathUtil {
   /**
@@ -44,10 +43,11 @@ export class XPathUtil {
    * @param xpath
    * @param doc {XMLDocument}
    * @param fore
+   * @param namespaceResolver {function} optional namespace resolver function
    * @return {Node|Attr}
    */
-  static createNodesFromXPath(xpath, doc, fore) {
-    const resolveNamespace = createNamespaceResolver(xpath, fore);
+  static createNodesFromXPath(xpath, doc, fore, namespaceResolver = null) {
+    const resolveNamespace = namespaceResolver || (() => undefined);
 
     if (!doc) {
       doc = document.implementation.createDocument(null, null, null); // Create a new XML document if not provided

package/src/DataObserver.js

@@ -1,181 +0,0 @@
-/* Usage:
-
-// Create or load your XML document
-const xmlString = `
-  <root>
-    <item id="1">Initial Value</item>
-  </root>
-`;
-const parser = new DOMParser();
-const xmlDoc = parser.parseFromString(xmlString, "application/xml");
-const rootNode = xmlDoc.querySelector("root");
-
-// Create an instance of the DataObserver
-const xmlObserver = new DataObserver(200);
-
-// Define a callback to process mutations
-const handleXMLMutations = (mutationsList) => {
-  console.log("XML Mutations:", mutationsList);
-};
-
-// Attach the observer to the XML root node
-xmlObserver.observe(rootNode, handleXMLMutations);
-
-// Modify the XML document to trigger mutations
-setTimeout(() => {
-  const newItem = xmlDoc.createElement("item");
-  newItem.textContent = "Newly Added Item";
-  rootNode.appendChild(newItem); // This triggers a mutation
-}, 1000);
-
-For JSON:
-// Create a JSON object
-const jsonObject = {
-  name: "John Doe",
-  age: 30,
-  hobbies: ["reading", "coding"],
-};
-
-// Create an instance of the DataObserver
-const jsonObserver = new DataObserver(200);
-
-// Define a callback to process changes
-const handleJSONChanges = (changesList) => {
-  console.log("JSON Changes:", changesList);
-};
-
-// Attach the observer to the JSON object
-jsonObserver.observe(jsonObject, handleJSONChanges);
-
-// Modify the JSON object to trigger changes
-setTimeout(() => {
-  jsonObject.name = "Jane Doe"; // This triggers a mutation
-  jsonObject.age = 31; // Another mutation
-  delete jsonObject.hobbies; // This triggers a delete mutation
-}, 1000);
-
-*/
-export class DataObserver {
-    constructor(debounceTime = 0) {
-        this.observer = null; // Placeholder for MutationObserver (for XML)
-        this.debounceTime = debounceTime; // Time in milliseconds for optional debouncing
-        this.mutationsQueue = []; // To batch process mutations
-        this.debounceTimer = null; // Timer for debouncing
-        this.jsonProxy = null; // Proxy for JSON observation
-    }
-
-    /**
-     * Attaches an observer to the given rootNode (DOM Node or JSON object)
-     * @param {Node|Object} rootNode - The XML DOM node or JSON object to observe
-     * @param {Function} callback - Function to process batch mutations
-     */
-    observe(rootNode, callback) {
-        if (rootNode instanceof Node) {
-            // Handle XML Node
-            this.observeXML(rootNode, callback);
-        } else if (typeof rootNode === "object" && rootNode !== null) {
-            // Handle JSON Object
-            this.observeJSON(rootNode, callback);
-        } else {
-            throw new Error("Invalid rootNode. Must be a DOM Node or a JSON object.");
-        }
-    }
-
-    /**
-     * Observes changes in an XML DOM node
-     * @param {Node} xmlNode - The XML DOM node to observe
-     * @param {Function} callback - Function to process batch mutations
-     */
-    observeXML(xmlNode, callback) {
-        // Initialize a new MutationObserver
-        this.observer = new MutationObserver((mutationsList) => {
-            this.mutationsQueue.push(...mutationsList);
-
-            if (this.debounceTime > 0) {
-                clearTimeout(this.debounceTimer); // Clear previous timer
-                this.debounceTimer = setTimeout(() => {
-                    this.processMutations(callback);
-                }, this.debounceTime);
-            } else {
-                this.processMutations(callback);
-            }
-        });
-
-        // Start observing the XML node
-        this.observer.observe(xmlNode, {
-            characterData: true,
-            childList: true,
-            subtree: true,
-        });
-    }
-
-    /**
-     * Observes changes in a JSON object using a proxy
-     * @param {Object} jsonObject - The JSON object to observe
-     * @param {Function} callback - Function to process changes
-     */
-    observeJSON(jsonObject, callback) {
-        const handler = {
-            set: (target, key, value) => {
-                this.mutationsQueue.push({ type: "update", target, key, value });
-
-                if (this.debounceTime > 0) {
-                    clearTimeout(this.debounceTimer); // Clear previous timer
-                    this.debounceTimer = setTimeout(() => {
-                        this.processMutations(callback);
-                    }, this.debounceTime);
-                } else {
-                    this.processMutations(callback);
-                }
-
-                // Perform the actual update
-                target[key] = value;
-                return true;
-            },
-
-            deleteProperty: (target, key) => {
-                this.mutationsQueue.push({ type: "delete", target, key });
-
-                if (this.debounceTime > 0) {
-                    clearTimeout(this.debounceTimer); // Clear previous timer
-                    this.debounceTimer = setTimeout(() => {
-                        this.processMutations(callback);
-                    }, this.debounceTime);
-                } else {
-                    this.processMutations(callback);
-                }
-
-                // Perform the actual delete
-                return delete target[key];
-            },
-        };
-
-        this.jsonProxy = new Proxy(jsonObject, handler);
-    }
-
-    /**
-     * Processes the mutations batch and clears the queue
-     * @param {Function} callback - Function to handle the batch of mutations
-     */
-    processMutations(callback) {
-        if (this.mutationsQueue.length > 0) {
-            callback(this.mutationsQueue); // Pass the batch to the callback
-            this.mutationsQueue = []; // Clear the queue
-        }
-    }
-
-    /**
-     * Disconnects the observer and clears any pending debounce timer
-     */
-    disconnect() {
-        if (this.observer) {
-            this.observer.disconnect(); // Disconnect the MutationObserver
-            this.observer = null;
-        }
-        if (this.debounceTimer) {
-            clearTimeout(this.debounceTimer); // Clear any pending debounce timer
-        }
-        this.mutationsQueue = []; // Clear the mutation queue
-        this.jsonProxy = null; // Clear JSON proxy reference
-    }
-}