@repobit/dex-store-elements 1.1.0

package/dist/src/nodes/node.state.js

@@ -0,0 +1,742 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var StateNode_1;
+import { derivedContext } from "../contexts/context.derived.js";
+import { eventContext } from "../contexts/context.event.js";
+import { stateContext } from "../contexts/context.state.js";
+import { storeContext } from "../contexts/context.store.js";
+import { ActionEvent, CollectActionEvent, CollectOptionEvent, CollectUpdateByDeltaEvent, UpdateByDeltaEvent } from "../events/events.js";
+import { toDSLContext } from "../renders/context.js";
+import eta from "../templating/eta.js";
+import { consume, provide } from "@lit/context";
+import { Task } from "@lit/task";
+import { LitElement } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import morph from 'nanomorph';
+if (!window.Promise.withResolvers) {
+    window.Promise.withResolvers = function () {
+        let resolve, reject;
+        const promise = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
+        });
+        return { resolve, reject, promise };
+    };
+}
+let StateNode = StateNode_1 = class StateNode extends LitElement {
+    constructor() {
+        super(...arguments);
+        this.autoForward = true;
+        this.noCollect = false;
+        this.storeName = Symbol("bd-state");
+        // If true, ignore events coming from parent context; only react to
+        // events originating inside this subtree (DOM-bubbled via listeners).
+        this.ignoreEventsParent = false;
+        /**
+         * all options as seens by this node
+         * options + partialOptions
+         */
+        this._options = new Map();
+        /**
+         * all actions as seens by this node
+         */
+        this._actions = new Map();
+        /**
+         * all delta updates as seens by this node
+         * changes that affect only devices and subscription
+         */
+        this._deltaUpdates = new Map();
+        /**
+         * all product changes as seens by this node
+         */
+        this._partialOptions = new Map();
+        /**
+         * all product changes as seens by this node
+         */
+        this._partialBundleOptions = new Map();
+        /**
+         * Local state
+         */
+        this.state = {
+            price: {
+                min: {
+                    value: Number.MAX_SAFE_INTEGER,
+                    fmt: ""
+                },
+                max: {
+                    value: Number.MIN_SAFE_INTEGER,
+                    fmt: ""
+                },
+                monthly: {
+                    min: {
+                        value: Number.MAX_SAFE_INTEGER,
+                        fmt: ""
+                    },
+                    max: {
+                        value: Number.MIN_SAFE_INTEGER,
+                        fmt: ""
+                    }
+                }
+            },
+            discountedPrice: {
+                min: {
+                    value: Number.MAX_SAFE_INTEGER,
+                    fmt: ""
+                },
+                max: {
+                    value: Number.MIN_SAFE_INTEGER,
+                    fmt: ""
+                },
+                monthly: {
+                    min: {
+                        value: Number.MAX_SAFE_INTEGER,
+                        fmt: ""
+                    },
+                    max: {
+                        value: Number.MIN_SAFE_INTEGER,
+                        fmt: ""
+                    }
+                }
+            },
+            discount: {
+                min: {
+                    value: Number.MAX_SAFE_INTEGER,
+                    fmt: ""
+                },
+                max: {
+                    value: Number.MIN_SAFE_INTEGER,
+                    fmt: ""
+                },
+                monthly: {
+                    min: {
+                        value: Number.MAX_SAFE_INTEGER,
+                        fmt: ""
+                    },
+                    max: {
+                        value: Number.MIN_SAFE_INTEGER,
+                        fmt: ""
+                    }
+                },
+                percentage: {
+                    min: {
+                        value: Number.MAX_SAFE_INTEGER,
+                        fmt: ""
+                    },
+                    max: {
+                        value: Number.MIN_SAFE_INTEGER,
+                        fmt: ""
+                    },
+                    monthly: {
+                        min: {
+                            value: Number.MAX_SAFE_INTEGER,
+                            fmt: ""
+                        },
+                        max: {
+                            value: Number.MIN_SAFE_INTEGER,
+                            fmt: ""
+                        }
+                    }
+                }
+            }
+        };
+        this._computeTask = new Task(this, {
+            task: async (_, { signal }) => {
+                const isActive = () => {
+                    if (signal.aborted) {
+                        throw new DOMException('Task aborted', `AbortError ${this.storeName.toString()}`);
+                    }
+                };
+                // runs whenever _store or version changes
+                try {
+                    const computed = await this._computeState(isActive);
+                    await this._computeContext(computed, isActive);
+                    return computed ?? [];
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                }
+                catch (e) { /* empty */ }
+            },
+            args: () => [this.store]
+        });
+        // Default event forwarder for simple pass-through nodes (e.g., root/context)
+        this._defaultForwardEventTask = new Task(this, {
+            task: async ([evt, auto]) => {
+                if (!evt || !auto)
+                    return;
+                this._forwardEvent(evt);
+                this._notifyParent();
+            },
+            args: () => [this._event, this.autoForward]
+        });
+        // Keep `_event` in sync with either DOM events or parent context,
+        // depending on `ignoreEventsParent`.
+        this._syncEventTask = new Task(this, {
+            task: async ([fromParent, fromDom, ignoreParent]) => {
+                // Track last-seen refs so we can choose the freshest source
+                const domChanged = fromDom !== this._prevDomEventRef;
+                const parentChanged = fromParent !== this._prevParentEventRef;
+                this._prevDomEventRef = fromDom;
+                this._prevParentEventRef = fromParent;
+                if (ignoreParent) {
+                    this._event = fromDom ?? undefined;
+                    return;
+                }
+                if (domChanged && !parentChanged) {
+                    this._event = fromDom ?? undefined;
+                    return;
+                }
+                if (parentChanged && !domChanged) {
+                    this._event = fromParent ?? undefined;
+                    return;
+                }
+                if (domChanged && parentChanged) {
+                    // If both changed in the same microtask, prefer DOM-originated
+                    this._event = fromDom ?? fromParent ?? undefined;
+                    return;
+                }
+                // Neither changed; keep current, but if nothing set yet, fall back
+                if (this._event === undefined) {
+                    this._event = fromDom ?? fromParent ?? undefined;
+                }
+            },
+            args: () => [this._eventParent, this._eventDom, this.ignoreEventsParent]
+        });
+        this._collectToggleTask = new Task(this, {
+            task: async ([noCollect]) => {
+                const prev = this._prevCollect;
+                this._prevCollect = !noCollect; // track last 'collect' state for edge detection
+                if (prev === undefined) {
+                    // Initial mount: register only if collecting (noCollect=false)
+                    if (!noCollect)
+                        this._notifyParent();
+                    return;
+                }
+                // prev represents prior collect state
+                const currentCollect = !noCollect;
+                if (currentCollect && !prev) {
+                    this._notifyParent();
+                }
+                else if (!currentCollect && prev) {
+                    this.dispatchEvent(new CollectOptionEvent({ name: this.storeName, options: null }));
+                }
+            },
+            args: () => [this.noCollect]
+        });
+        // Cache original templates per element so we can re-render from the original innerHTML
+        this._tplElementTemplates = new WeakMap();
+        this._tplAttrTemplates = new WeakMap();
+        this._etaRenderTask = new Task(this, {
+            task: async ([state, derived]) => {
+                if (!state)
+                    return;
+                if (!this.shouldRunEtaStateRender())
+                    return;
+                // Provide 'it' derived from DSL context
+                const it = await toDSLContext({ state, derived });
+                await this._renderEtaTemplates(it);
+            },
+            args: () => [this.state, this._derived]
+        });
+    }
+    /**
+     * all options computed by this node
+     * options * actions
+     */
+    get computedOptions() {
+        return this._computeTask.value;
+    }
+    // Allow subclasses (e.g., OptionNode) to disable the base Eta render
+    // when they provide their own option-specific rendering pipeline.
+    shouldRunEtaStateRender() { return true; }
+    _isStateNodeElement(el) {
+        if (el instanceof StateNode_1)
+            return true;
+        const t = el.tagName;
+        return t === 'BD-STATE' || t === 'BD-PRODUCT' || t === 'BD-OPTION' || t === 'BD-CONTEXT';
+    }
+    _hasNestedStateNode(el) {
+        return !!el.querySelector?.('bd-state,bd-product,bd-option,bd-context');
+    }
+    _safeEtaRender(entry, data, { onErrorReturnInput = false } = {}) {
+        try {
+            if (!entry.fn) {
+                entry.fn = eta.compile(entry.src);
+            }
+            const out = eta.render(entry.fn, data);
+            return typeof out === 'string' ? out : String(out ?? '');
+        }
+        catch (err) {
+            console.error('Eta render error:', err);
+            return onErrorReturnInput ? entry.src : '';
+        }
+    }
+    async _renderEtaAttributes(el, data) {
+        // any attribute whose value contains '{{' is treated as an Eta template
+        const names = el.getAttributeNames();
+        let cache = this._tplAttrTemplates.get(el);
+        if (!cache) {
+            cache = new Map();
+            this._tplAttrTemplates.set(el, cache);
+        }
+        // Implicit any-attribute templates (heuristic: contains '{{')
+        for (const a of names) {
+            const raw = el.getAttribute(a);
+            if (!raw || !raw.includes('{{'))
+                continue;
+            const key = `imp:${a}`;
+            let entry = cache.get(key);
+            if (!entry || entry.src !== raw) {
+                entry = { src: raw };
+                cache.set(key, entry);
+            }
+            const rendered = this._safeEtaRender(entry, data, { onErrorReturnInput: true });
+            if (rendered !== raw) {
+                try {
+                    el.setAttribute(a, rendered);
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    _hasRenderNodes(el) {
+        return !!el.querySelector?.('[data-store-render]');
+    }
+    async _morphElementFromHTML(el, html) {
+        try {
+            const wrapper = el.cloneNode(false);
+            wrapper.innerHTML = html;
+            morph(el, wrapper);
+        }
+        catch {
+            el.innerHTML = html;
+        }
+    }
+    async _renderEtaTemplates(context) {
+        // Traverse descendants; for any element that does NOT contain a nested state node,
+        // treat its innerHTML as a single Eta template and render/morph the entire subtree.
+        const visit = async (root) => {
+            for (const child of Array.from(root.children)) {
+                if (!(child instanceof HTMLElement))
+                    continue;
+                // Always allow attribute-level Eta on any node in this subtree
+                await this._renderEtaAttributes(child, context);
+                if (this._isStateNodeElement(child) && child !== this) {
+                    continue; // nested provider; let it handle its subtree
+                }
+                if (this._hasNestedStateNode(child)) {
+                    // drill down until we reach leaves without nested state nodes
+                    await visit(child);
+                    continue;
+                }
+                // If subtree contains render nodes, recurse into it but don't morph at this level
+                if (this._hasRenderNodes(child)) {
+                    await visit(child);
+                    continue;
+                }
+                // Skip elements managed by the render pipeline
+                if (child.hasAttribute('data-store-render')) {
+                    continue;
+                }
+                let entry = this._tplElementTemplates.get(child);
+                if (!entry) {
+                    const src = child.innerHTML ?? '';
+                    entry = { src };
+                    this._tplElementTemplates.set(child, entry);
+                }
+                const out = this._safeEtaRender(entry, context, { onErrorReturnInput: true });
+                await this._morphElementFromHTML(child, out);
+            }
+        };
+        await visit(this);
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.addEventListener(CollectActionEvent.eventName, this._collectActionEvent);
+        this.addEventListener(CollectUpdateByDeltaEvent.eventName, this._collectUpdateByDeltaEvent);
+        this.addEventListener(CollectOptionEvent.eventName, this._collectOptionEvent);
+        [ActionEvent, UpdateByDeltaEvent].forEach(e => this.addEventListener(e.eventName, this._eventChange));
+    }
+    remove() {
+        this.dispatchEvent(new CollectOptionEvent({ name: this.storeName, options: null }));
+        super.remove();
+    }
+    disconnectedCallback() {
+        this.removeEventListener(CollectActionEvent.eventName, this._collectActionEvent);
+        this.removeEventListener(CollectUpdateByDeltaEvent.eventName, this._collectUpdateByDeltaEvent);
+        this.removeEventListener(CollectOptionEvent.eventName, this._collectOptionEvent);
+        [ActionEvent, UpdateByDeltaEvent].forEach(e => this.removeEventListener(e.eventName, this._eventChange));
+        this._options.clear();
+        this._actions.clear();
+        this._partialOptions.clear();
+        super.disconnectedCallback();
+    }
+    _eventChange(e) {
+        e.stopPropagation();
+        // ignore if source matches ignore list
+        if (this._isIgnoredSource(e)) {
+            return;
+        }
+        this._eventDom = e;
+    }
+    _forwardEvent(e = this._event) {
+        this._fEvent = e;
+    }
+    _collectOptionEvent(e) {
+        if (e.target === this) {
+            return;
+        }
+        e.stopPropagation();
+        this.collectOption(e.detail);
+    }
+    collectOption({ name, options }) {
+        //node has disconected
+        if (options === null) {
+            this._options.delete(name);
+        }
+        else {
+            this._options.set(name, options);
+        }
+        this._computeTask.abort();
+        this._computeTask.run();
+        this._notifyParent();
+    }
+    _collectActionEvent(e) {
+        if (e.target === this) {
+            return;
+        }
+        e.stopPropagation();
+        const { name, action } = e.detail;
+        //node has disconected
+        if (action === null) {
+            this._actions.delete(name);
+            this._partialOptions.delete(name);
+            this._partialBundleOptions.delete(name);
+        }
+        else if (!action.id && (action.devices || action.subscription)) {
+            this._actions.set(name, action);
+        }
+        else {
+            if (action.bundle) {
+                this._partialBundleOptions.set(name, action);
+            }
+            else {
+                this._partialOptions.set(name, action);
+            }
+        }
+        this._computeTask.abort();
+        this._computeTask.run();
+        this._notifyParent();
+    }
+    _collectUpdateByDeltaEvent(e) {
+        if (e.target === this) {
+            return;
+        }
+        const { name, update } = e.detail;
+        //node has disconected
+        if (update === null) {
+            this._deltaUpdates.delete(name);
+        }
+        else {
+            this._deltaUpdates.set(name, update);
+        }
+        this._computeTask.abort();
+        this._computeTask.run();
+        this._notifyParent();
+    }
+    async _computeState(isActive) {
+        const computed = new Set();
+        // 1) collect base options + partialOptions
+        for (const optsPromise of this._options.values()) {
+            isActive();
+            const opts = await optsPromise;
+            for (const opt of opts) {
+                isActive();
+                computed.add(opt);
+                await this._applyPartials(opt, computed, isActive);
+            }
+        }
+        // 2) apply full “actions”
+        for (const opt of [...computed]) {
+            isActive();
+            await this._applyActions(opt, computed, isActive);
+        }
+        // 3) apply full "delta updates"
+        for (const opt of [...computed]) {
+            isActive();
+            await this._applyDeltaUpdates(opt, computed, isActive);
+        }
+        // 3) combine bundles
+        for (const opt of [...computed]) {
+            isActive();
+            const bundles = [...this._partialBundleOptions.values()];
+            const combos = await this._applyBundles(opt, bundles);
+            combos.forEach(cb => cb && computed.add(cb));
+        }
+        return [...computed];
+    }
+    async _applyPartials(baseOpt, computed, isActive) {
+        for (const partial of this._partialOptions.values()) {
+            isActive();
+            if (!partial.id) {
+                continue;
+            }
+            const newProduct = await baseOpt.switchProduct({ id: partial.id, campaign: partial.campaign });
+            const newOpt = await newProduct?.getOption({ devices: partial.devices, subscription: partial.subscription });
+            if (newOpt)
+                computed.add(newOpt);
+        }
+    }
+    async _applyActions(baseOpt, computed, isActive) {
+        for (const action of this._actions.values()) {
+            isActive();
+            const newOpt = await baseOpt.getOption({
+                devices: action.devices ?? baseOpt.getDevices(),
+                subscription: action.subscription ?? baseOpt.getSubscription()
+            });
+            if (newOpt)
+                computed.add(newOpt);
+        }
+    }
+    async _applyDeltaUpdates(baseOpt, computed, isActive) {
+        const product = baseOpt.getProduct();
+        const baseDevices = product.getDevices().values;
+        const baseSubscriptions = product.getSubscriptions().values;
+        let devices = baseOpt.getDevices();
+        let subscription = baseOpt.getSubscription();
+        //corner case for input types that define an interval by themselves
+        const getValue = (action, startValue, minValue) => {
+            if (action.useAsValue) {
+                action.delta = 1;
+                return Number(action.min) || minValue;
+            }
+            else {
+                return startValue;
+            }
+        };
+        for (const action of this._deltaUpdates.values()) {
+            isActive();
+            // Loop until we can no longer apply the delta
+            while (true) {
+                isActive();
+                const values = action.type === "devices"
+                    ? baseDevices
+                    : baseSubscriptions;
+                const current = action.type === "devices"
+                    ? getValue(action, devices, baseDevices[0])
+                    : getValue(action, subscription, baseSubscriptions[0]);
+                const { newValue, done } = this._computeDelta(values, current, action);
+                if (done)
+                    break;
+                // Update the appropriate variable
+                if (action.type === "devices") {
+                    devices = newValue;
+                }
+                else {
+                    subscription = newValue;
+                }
+                // Fetch the new option and add it if exists
+                const newOpt = await baseOpt.getOption({ devices, subscription });
+                if (newOpt) {
+                    computed.add(newOpt);
+                }
+            }
+        }
+    }
+    /**
+   * Attempts to apply the given delta action to the current value.
+   * Returns the updated value and whether we've exhausted variants.
+   */
+    _computeDelta(values, current, action) {
+        const min = Number(action.min) || Number.MAX_SAFE_INTEGER;
+        const max = Number(action.max) || Number.MIN_SAFE_INTEGER;
+        // Handle "next" / "prev" stepping through a discrete list
+        if (action.delta === "next" || action.delta === "prev") {
+            const idx = values.findIndex(v => v === current);
+            const step = action.delta === "next" ? 1 : -1;
+            const candidate = values.at(idx + step);
+            if (candidate && (action.delta === "next" ? candidate <= min : candidate >= max)) {
+                return { newValue: candidate, done: false };
+            }
+            return { newValue: current, done: true };
+        }
+        // Handle numeric delta
+        const candidate = current + action.delta;
+        const isValid = action.delta > 0 ? candidate <= min : candidate >= max;
+        if (isValid) {
+            return { newValue: candidate, done: false };
+        }
+        return { newValue: current, done: true };
+    }
+    async _computeContext(options, isActive) {
+        function updateMinMax(range, value, formatted) {
+            if (range.min.value == null || value < range.min.value) {
+                range.min.value = value;
+                range.min.fmt = formatted;
+            }
+            if (range.max.value == null || value > range.max.value) {
+                range.max.value = value;
+                range.max.fmt = formatted;
+            }
+        }
+        for (const option of options) {
+            isActive();
+            updateMinMax(this.state.price, option.getPrice({ currency: false }), option.getPrice());
+            updateMinMax(this.state.price.monthly, option.getPrice({ monthly: true, currency: false }), option.getPrice({ monthly: true }));
+            updateMinMax(this.state.discountedPrice, option.getDiscountedPrice({ currency: false }), option.getDiscountedPrice());
+            updateMinMax(this.state.discountedPrice.monthly, option.getDiscountedPrice({ monthly: true, currency: false }), option.getDiscountedPrice({ monthly: true }));
+            updateMinMax(this.state.discount, option.getDiscount({ symbol: false }), option.getDiscount());
+            updateMinMax(this.state.discount.monthly, option.getDiscount({ monthly: true, symbol: false }), option.getDiscount({ monthly: true }));
+            updateMinMax(this.state.discount.percentage, option.getDiscount({ percentage: true, symbol: false }), option.getDiscount({ percentage: true }));
+            updateMinMax(this.state.discount.percentage.monthly, option.getDiscount({ monthly: true, percentage: true, symbol: false }), option.getDiscount({ monthly: true, percentage: true }));
+        }
+        this.state = { ...this.state };
+    }
+    async _getOption({ id, campaign, devices, subscription }, bundle = []) {
+        if (id && devices && subscription) {
+            const product = await this.store?.getProduct({ id, campaign });
+            return await product?.getOption({ devices, subscription, bundle });
+        }
+        return null;
+    }
+    async _applyBundles(baseOpt, bundles) {
+        const result = [];
+        const recurse = async (prefix, start) => {
+            for (let i = start; i < bundles.length; i++) {
+                const bundleOption = await this._getOption({
+                    id: bundles[i].id,
+                    campaign: bundles[i].campaign,
+                    devices: bundles[i].devices ?? baseOpt.getDevices(),
+                    subscription: bundles[i].subscription ?? baseOpt.getSubscription()
+                }, []);
+                if (!bundleOption) {
+                    continue;
+                }
+                const next = prefix.concat({
+                    devicesFixed: Boolean(bundles[i].devices),
+                    subscriptionFixed: Boolean(bundles[i].subscription),
+                    option: bundleOption
+                });
+                result.push(next);
+                await recurse(next, i + 1);
+            }
+        };
+        const bundleOption = async (option, bundles = []) => {
+            for (const bundle of bundles) {
+                const newOpt = await option.toogleBundle(bundle);
+                if (newOpt) {
+                    option = newOpt;
+                }
+                else {
+                    return null;
+                }
+            }
+            return option;
+        };
+        await recurse([], 0);
+        const x = await Promise.all(result.map(bundles => bundleOption(baseOpt, bundles)));
+        return x;
+    }
+    _notifyParent() {
+        if (this.noCollect)
+            return;
+        this.dispatchEvent(new CollectOptionEvent({
+            name: this.storeName,
+            options: this._computeTask.taskComplete
+        }));
+    }
+    async getUpdateComplete() {
+        const result = await super.getUpdateComplete();
+        await this._computeTask.taskComplete;
+        await this._defaultForwardEventTask.taskComplete;
+        await this._syncEventTask.taskComplete;
+        await this._collectToggleTask.taskComplete;
+        await this._etaRenderTask.taskComplete;
+        return result;
+    }
+    isDeviceAndSubscriptionChange(evt) {
+        return evt instanceof ActionEvent
+            && Boolean(evt.detail?.devices || evt.detail?.subscription)
+            && !evt.detail.bundle;
+    }
+    isBundleToogle(evt) {
+        return evt instanceof ActionEvent
+            && Boolean(evt.detail?.id)
+            && Boolean(evt.detail.bundle);
+    }
+    isProductChange(evt) {
+        return evt instanceof ActionEvent
+            && Boolean(evt.detail?.id)
+            && !evt.detail.bundle;
+    }
+    isActionEvent(evt) {
+        return this.isProductChange(evt) || this.isDeviceAndSubscriptionChange(evt);
+    }
+    isDeltaUpdate(evt) {
+        return evt instanceof UpdateByDeltaEvent;
+    }
+    _isIgnoredSource(e) {
+        const set = this._getIgnoreSet();
+        if (set.size === 0)
+            return false;
+        const id = e.detail?.storeId || "";
+        return set.has(id);
+    }
+    _getIgnoreSet() {
+        const raw = this.ignoreEvents;
+        if (!raw)
+            return new Set();
+        return new Set(raw
+            .split(',')
+            .map(s => s.trim())
+            .filter(Boolean));
+    }
+};
+__decorate([
+    property({ attribute: false })
+], StateNode.prototype, "autoForward", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'nocollect' })
+], StateNode.prototype, "noCollect", void 0);
+__decorate([
+    property({ attribute: 'ignoreevents' })
+], StateNode.prototype, "ignoreEvents", void 0);
+__decorate([
+    property()
+], StateNode.prototype, "storeName", void 0);
+__decorate([
+    property({ type: Boolean, attribute: 'ignore-events-parent' })
+], StateNode.prototype, "ignoreEventsParent", void 0);
+__decorate([
+    consume({ context: storeContext, subscribe: true }),
+    property({ attribute: false })
+], StateNode.prototype, "store", void 0);
+__decorate([
+    consume({ context: eventContext, subscribe: true }),
+    property({ attribute: false })
+], StateNode.prototype, "_eventParent", void 0);
+__decorate([
+    consume({ context: derivedContext, subscribe: true }),
+    property({ attribute: false })
+], StateNode.prototype, "_derived", void 0);
+__decorate([
+    property({ attribute: false })
+], StateNode.prototype, "_event", void 0);
+__decorate([
+    property({ attribute: false })
+], StateNode.prototype, "_eventDom", void 0);
+__decorate([
+    provide({ context: eventContext }),
+    property({ attribute: false })
+], StateNode.prototype, "_fEvent", void 0);
+__decorate([
+    provide({ context: stateContext }),
+    property({ attribute: false })
+], StateNode.prototype, "state", void 0);
+StateNode = StateNode_1 = __decorate([
+    customElement('bd-state')
+], StateNode);
+export { StateNode };
+//# sourceMappingURL=node.state.js.map