@lushly-dev/fast-element 3.0.1-preview.0 → 3.0.1-preview.1

package/dist/esm/trust/utils.js

@@ -0,0 +1,126 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { TRUST_KEY } from "./types.js";
+const warningSeverities = new Set([
+    "info",
+    "warning",
+    "caution",
+]);
+function isPlainObject(value) {
+    if (value === null || typeof value !== "object") {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+/**
+ * Normalize untrusted warnings: non-arrays yield `undefined`; entries without a string
+ * `code` and `message` are dropped; invalid `severity` / non-plain `details` are omitted.
+ */
+function sanitizeWarnings(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const warnings = [];
+    for (const entry of value) {
+        if (!isPlainObject(entry) ||
+            typeof entry.code !== "string" ||
+            typeof entry.message !== "string") {
+            continue;
+        }
+        const warning = { code: entry.code, message: entry.message };
+        if (warningSeverities.has(entry.severity)) {
+            warning.severity = entry.severity;
+        }
+        if (isPlainObject(entry.details)) {
+            warning.details = entry.details;
+        }
+        warnings.push(warning);
+    }
+    return warnings;
+}
+/**
+ * Extract trust signals from a CustomEvent.
+ * Returns empty object if no trust signals present.
+ * @public
+ */
+export function getTrustSignals(event) {
+    const detail = event.detail;
+    if (detail && typeof detail === "object" && TRUST_KEY in detail) {
+        const trust = detail[TRUST_KEY];
+        if (trust && typeof trust === "object") {
+            const signals = trust;
+            const confidence = signals.confidence;
+            const warnings = sanitizeWarnings(signals.warnings);
+            return Object.assign(Object.assign(Object.assign({}, (typeof confidence === "number" &&
+                Number.isFinite(confidence) &&
+                confidence >= 0 &&
+                confidence <= 1
+                ? { confidence }
+                : {})), (typeof signals.reasoning === "string"
+                ? { reasoning: signals.reasoning }
+                : {})), (warnings !== undefined ? { warnings } : {}));
+        }
+    }
+    return {};
+}
+/**
+ * Check if an event has trust signals.
+ * @public
+ */
+export function hasTrustSignals(event) {
+    const signals = getTrustSignals(event);
+    return (signals.confidence !== undefined ||
+        signals.reasoning !== undefined ||
+        signals.warnings !== undefined);
+}
+/**
+ * Wrap detail with trust signals.
+ *
+ * @remarks
+ * - Plain objects are copied and the signals are added under {@link TRUST_KEY}.
+ * - Anything else (primitives, arrays, Dates, class instances, ...) is wrapped in a
+ *   `{ value, __trust }` envelope so it is never spread into a different shape.
+ * - A `__trust` key already present on a plain-object detail is caller-supplied
+ *   (often from parsed JSON) and is never kept: it is replaced by the real signals,
+ *   or dropped when there are none, so detail data cannot forge trust signals.
+ *
+ * @internal
+ */
+export function wrapDetailWithTrust(detail, signals) {
+    const { confidence, reasoning } = signals !== null && signals !== void 0 ? signals : {};
+    const warnings = Array.isArray(signals === null || signals === void 0 ? void 0 : signals.warnings) ? signals.warnings : undefined;
+    if (confidence === undefined && reasoning === undefined && warnings === undefined) {
+        if (isPlainObject(detail) && TRUST_KEY in detail) {
+            const _a = detail, _b = TRUST_KEY, _forged = _a[_b], rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+            return rest;
+        }
+        return detail; // No-op when no trust signals
+    }
+    if (confidence !== undefined &&
+        (!Number.isFinite(confidence) || confidence < 0 || confidence > 1)) {
+        throw new RangeError("Trust confidence must be a finite number from 0 to 1.");
+    }
+    const trust = {};
+    if (confidence !== undefined)
+        trust.confidence = confidence;
+    if (reasoning !== undefined)
+        trust.reasoning = reasoning;
+    if (warnings !== undefined)
+        trust.warnings = warnings.map(warning => (Object.assign({}, warning)));
+    if (isPlainObject(detail)) {
+        const _c = detail, _d = TRUST_KEY, _forged = _c[_d], rest = __rest(_c, [typeof _d === "symbol" ? _d : _d + ""]);
+        return Object.assign(Object.assign({}, rest), { [TRUST_KEY]: trust });
+    }
+    // Wrap everything that is not a plain object in an envelope
+    return { value: detail, [TRUST_KEY]: trust };
+}

package/dist/esm/utilities.js

@@ -0,0 +1,140 @@
+import { DOM } from "./dom.js";
+import { ExecutionContext } from "./observation/observable.js";
+import { nextId } from "./templating/markup.js";
+/**
+ * Retrieves the "composed parent" element of a node, ignoring DOM tree boundaries.
+ * When the parent of a node is a shadow-root, it will return the host
+ * element of the shadow root. Otherwise it will return the parent node or null if
+ * no parent node exists.
+ * @param element - The element for which to retrieve the composed parent
+ *
+ * @public
+ */
+export function composedParent(element) {
+    const parentNode = element.parentElement;
+    if (parentNode) {
+        return parentNode;
+    }
+    else {
+        const rootNode = element.getRootNode();
+        if (rootNode.host instanceof HTMLElement) {
+            // this is shadow-root
+            return rootNode.host;
+        }
+    }
+    return null;
+}
+/**
+ * Determines if the reference element contains the test element in a "composed" DOM tree that
+ * ignores shadow DOM boundaries.
+ *
+ * Returns true of the test element is a descendent of the reference, or exists in
+ * a shadow DOM that is a logical descendent of the reference. Otherwise returns false.
+ * @param reference - The element to test for containment against.
+ * @param test - The element being tested for containment.
+ *
+ * @public
+ */
+export function composedContains(reference, test) {
+    let current = test;
+    while (current !== null) {
+        if (current === reference) {
+            return true;
+        }
+        current = composedParent(current);
+    }
+    return false;
+}
+/**
+ * An extension of MutationObserver that supports unobserving nodes.
+ * @internal
+ */
+export class UnobservableMutationObserver extends MutationObserver {
+    /**
+     * Creates an instance of UnobservableMutationObserver.
+     * @param callback - The callback to invoke when observed nodes are changed.
+     */
+    constructor(callback) {
+        function handler(mutations) {
+            this.callback.call(null, mutations.filter(record => this.observedNodes.has(record.target)));
+        }
+        super(handler);
+        this.callback = callback;
+        this.observedNodes = new Set();
+    }
+    observe(target, options) {
+        this.observedNodes.add(target);
+        super.observe(target, options);
+    }
+    unobserve(target) {
+        this.observedNodes.delete(target);
+        if (this.observedNodes.size < 1) {
+            this.disconnect();
+        }
+    }
+}
+/**
+ * Bridges between ViewBehaviors and HostBehaviors, enabling a host to
+ * control ViewBehaviors.
+ * @public
+ */
+export const ViewBehaviorOrchestrator = Object.freeze({
+    /**
+     * Creates a ViewBehaviorOrchestrator.
+     * @param source - The source to to associate behaviors with.
+     * @returns A ViewBehaviorOrchestrator.
+     */
+    create(source) {
+        const behaviors = [];
+        const targets = {};
+        let unbindables = null;
+        let isConnected = false;
+        return {
+            source,
+            context: ExecutionContext.default,
+            targets,
+            get isBound() {
+                return isConnected;
+            },
+            addBehaviorFactory(factory, target) {
+                var _a, _b, _c, _d;
+                const compiled = factory;
+                compiled.id = (_a = compiled.id) !== null && _a !== void 0 ? _a : nextId();
+                compiled.targetNodeId = (_b = compiled.targetNodeId) !== null && _b !== void 0 ? _b : nextId();
+                compiled.targetTagName = (_c = target.tagName) !== null && _c !== void 0 ? _c : null;
+                compiled.policy = (_d = compiled.policy) !== null && _d !== void 0 ? _d : DOM.policy;
+                this.addTarget(compiled.targetNodeId, target);
+                this.addBehavior(compiled.createBehavior());
+            },
+            addTarget(nodeId, target) {
+                targets[nodeId] = target;
+            },
+            addBehavior(behavior) {
+                behaviors.push(behavior);
+                if (isConnected) {
+                    behavior.bind(this);
+                }
+            },
+            onUnbind(unbindable) {
+                if (unbindables === null) {
+                    unbindables = [];
+                }
+                unbindables.push(unbindable);
+            },
+            connectedCallback(controller) {
+                if (!isConnected) {
+                    isConnected = true;
+                    behaviors.forEach(x => x.bind(this));
+                }
+            },
+            disconnectedCallback(controller) {
+                if (isConnected) {
+                    isConnected = false;
+                    if (unbindables !== null) {
+                        unbindables.forEach(x => x.unbind(this));
+                    }
+                }
+            },
+        };
+    },
+});