{"version":3,"sources":["../../../../src/lib/AreSignals/AreSignals.component.ts"],"names":[],"mappings":"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","file":"AreSignals.component.mjs","sourcesContent":["import { A_Caller, A_Component, A_Context, A_Feature, A_Inject, A_Meta, A_Scope, A_TYPES__Ctor } from \"@adaas/a-concept\";\nimport { A_SignalBusFeatures, A_Signal, A_SignalState, A_SignalVector } from \"@adaas/a-utils/a-signal\";\nimport { A_Logger } from \"@adaas/a-utils/a-logger\";\nimport { AreContext } from \"@adaas/are/component/Are.context\";\nimport { AreFeatures, AreSignalFeatureKey } from \"@adaas/are/component/Are.constants\";\nimport { AreNode } from \"@adaas/are/node/AreNode.entity\";\nimport { AreNodeFeatures } from \"@adaas/are/node/AreNode.constants\";\nimport { AreEvent } from \"@adaas/are/event/AreEvent.context\";\nimport { A_Frame } from \"@adaas/a-frame/core\";\nimport { AreSignalsMeta } from \"./AreSignals.meta\";\nimport { AreSignalsContext } from \"./AreSignals.context\";\nimport { Are } from \"@adaas/are/component/Are.component\";\n\n\n\n@A_Frame.Define({\n    namespace: 'A-ARE',\n    description: 'AreSignals is the central signal bus component within the ARE framework. It listens for incoming signal vectors and dispatches them to all subscribed root nodes, enabling reactive, event-driven rendering and lifecycle management across the component tree.'\n})\n@A_Meta.Define(AreSignalsMeta)\nexport class AreSignals extends A_Component {\n\n    @A_Feature.Extend({\n        name: A_SignalBusFeatures.onNext,\n    })\n    async handleSignalVector(\n        @A_Inject(A_SignalVector) vector: A_SignalVector,\n        @A_Inject(AreSignalsContext) context: AreSignalsContext,\n        @A_Inject(A_SignalState) state: A_SignalState,\n        @A_Inject(A_Scope) scope: A_Scope,\n        @A_Inject(A_Logger) logger?: A_Logger,\n    ) {\n        logger?.debug(`Handling Signal Vector with ${context.subscribers.size} root nodes.`, vector);\n\n        try {\n            for (const sub of context.subscribers) {\n\n                // Skip subscriber roots that are not backed by a real Are\n                // component. Stray top-level template nodes (whitespace text,\n                // HTML comments, a <script> tag, etc.) are tokenized as roots\n                // and subscribe to the bus, but they own no signal handlers and\n                // no managed outlet — re-emitting to them only triggers a\n                // redundant re-interpret that fails its mount-point lookup.\n                // Note: `node.component` resolves the PascalCase entity name and\n                // for primitive nodes (are-text, are-comment) returns the node's\n                // own class instance, which is NOT an `Are` component — so an\n                // `instanceof Are` check is required to distinguish real\n                // component roots from these. Only `Are`-backed nodes can\n                // meaningfully react to signals.\n                if (!(sub.component instanceof Are)) continue;\n\n                const callScope = new A_Scope({\n                    fragments: [new AreEvent(\n                        AreFeatures.onSignal, {\n                        vector\n                    })]\n                })\n                    .import(scope, sub.scope);\n\n                logger?.debug('Emitting signal for sub node:', vector);\n\n                await sub.emit(callScope);\n\n                callScope.destroy();\n\n                // ─────────────────────────────────────────────────────────────\n                // Typed dispatch\n                // ─────────────────────────────────────────────────────────────\n                // For each signal that was ACTUALLY dispatched on THIS tick,\n                // also emit a per-type event so handlers registered via\n                // `@Are.Signal(SignalCtor)` receive only the signals they care\n                // about. The composed feature name (`onSignal:<signal-entity>`)\n                // is matched on the component's feature registry; components\n                // without a typed handler simply see a no-op chain.\n                //\n                // IMPORTANT: we iterate the freshly-dispatched signals (the\n                // ones registered as entities in the bus-next-scope by\n                // A_SignalBus.next()), NOT the accumulated `vector` from\n                // A_SignalState. The accumulated vector also carries signals\n                // from PREVIOUS ticks; firing typed handlers for those would\n                // (a) re-invoke the handler on every subsequent tick while the\n                // signal lingers in state — breaking the \"fires only for its\n                // signal type\" condition — and (b) fail to resolve\n                // `@A_Inject(SignalCtor)` because older signals are no longer\n                // registered in this scope. Restricting to the fresh signals\n                // keeps both the firing condition and the injection correct.\n                const dispatchedSignals = scope.resolveFlatAll<A_Signal>(A_Signal);\n\n                for (const signal of dispatchedSignals) {\n                    if (!signal) continue;\n\n                    const ctor = signal.constructor as A_TYPES__Ctor<typeof signal> & { entity?: string; name: string };\n                    const typedFeatureName = AreSignalFeatureKey(ctor);\n\n                    const typedScope = new A_Scope({\n                        fragments: [new AreEvent(typedFeatureName, {\n                            vector,\n                            signal,\n                        })]\n                    })\n                        .import(scope, sub.scope);\n\n                    await sub.emit(typedScope);\n\n                    typedScope.destroy();\n                }\n            }\n        } catch (error) {\n            logger?.error(error);\n        }\n    }\n\n\n\n    // -----------------------------------------------------------------------------------------\n    // ----------------------------Are-Node Event Section----------------------------------------\n    // -----------------------------------------------------------------------------------------\n    /**\n     * Handles events triggered on the AreNode\n     * \n     * @param node \n     * @param scope \n     * @param event \n     * @param scene \n     * @param feature \n     * @param args \n     */\n    @A_Feature.Extend({\n        name: AreNodeFeatures.onEmit,\n        scope: [AreNode]\n    })\n    async propagateEvent(\n        @A_Inject(A_Caller) node: AreNode,\n        @A_Inject(A_Scope) scope: A_Scope,\n        @A_Inject(AreEvent) event: AreEvent,\n        @A_Inject(A_Feature) feature: A_Feature,\n        @A_Inject(A_Logger) logger?: A_Logger,\n        ...args: any[]\n    ) {\n        let currentNode = node;\n        let target = node;\n\n        while (currentNode && currentNode.parent) {\n            if (currentNode.component) {\n                target = currentNode;\n                break;\n            }\n            currentNode = currentNode.parent;\n        }\n\n        if (target.component)\n            await feature.chain(target.component, event.name, scope);\n    }\n\n\n    // -----------------------------------------------------------------------------------------\n    // ----------------------------Are-Component Notify Section---------------------------------\n    // -----------------------------------------------------------------------------------------\n    /**\n     * Notifies all mounted nodes whose component is exactly the specified constructor\n     * (strict match — subclasses are excluded).\n     *\n     * @param ctor  - The Are component constructor to target\n     * @param event - The event to emit to all matching nodes\n     */\n    async notifyExact<T extends Are>(\n        ctor: A_TYPES__Ctor<T>,\n        event: AreEvent,\n    ): Promise<void> {\n        const context = A_Context.scope(this).resolve(AreContext);\n\n        if (!context) return;\n\n        for (const root of context.roots) {\n            await this.traverseAndNotify(root, event, (component) => component.constructor === ctor);\n        }\n    }\n\n    /**\n     * Notifies all mounted nodes whose component is an instance of the specified\n     * constructor, including nodes backed by subclasses (polymorphic match).\n     *\n     * @param ctor  - The Are component constructor to target\n     * @param event - The event to emit to all matching nodes\n     */\n    async notifyAll<T extends Are>(\n        ctor: A_TYPES__Ctor<T>,\n        event: AreEvent,\n    ): Promise<void> {\n        const context = A_Context.scope(this).resolve(AreContext);\n\n        if (!context) return;\n\n        for (const root of context.roots) {\n            await this.traverseAndNotify(root, event, (component) => component instanceof ctor);\n        }\n    }\n\n    /**\n     * Notifies all mounted nodes whose component matches the specified constructor.\n     * \n     * By default uses polymorphic matching (includes subclasses). Pass `{ exact: true }`\n     * to restrict to the exact constructor only.\n     *\n     * @param ctor    - The Are component constructor to target\n     * @param event   - The event to emit to all matching nodes\n     * @param options - `exact`: when true, subclasses are excluded (defaults to false)\n     */\n    async notify<T extends Are>(\n        ctor: A_TYPES__Ctor<T>,\n        event: AreEvent,\n        options?: { exact?: boolean },\n    ): Promise<void> {\n        if (options?.exact) {\n            return this.notifyExact(ctor, event);\n        }\n        return this.notifyAll(ctor, event);\n    }\n\n    protected async traverseAndNotify(\n        node: AreNode,\n        event: AreEvent,\n        match: (component: Are) => boolean,\n    ): Promise<void> {\n        if (node.component && match(node.component)) {\n            await node.emit(event);\n        }\n\n        for (const child of node.children) {\n            await this.traverseAndNotify(child, event, match);\n        }\n    }\n}"]}