@ng-atomic/core 19.0.0-preview.8 → 19.1.0

package/fesm2022/ng-atomic-core.mjs

@@ -1,129 +1,144 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injector, runInInjectionContext, inject, Injectable, EventEmitter, isSignal, computed, Pipe, PLATFORM_ID, ViewContainerRef, DestroyRef, ElementRef, input, reflectComponentType, Output, Directive, ApplicationRef } from '@angular/core';
+import { Injectable, InjectionToken, Injector, runInInjectionContext, inject, EventEmitter, isSignal, computed, Pipe, PLATFORM_ID, ViewContainerRef, DestroyRef, ElementRef, input, output, reflectComponentType, Directive, ApplicationRef } from '@angular/core';
+import { merge } from 'lodash-es';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import Ajv from 'ajv';
 import { plainToInstance } from 'class-transformer';
 import { validateSync } from 'class-validator';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { isPlatformBrowser } from '@angular/common';
 import { SIGNAL } from '@angular/core/primitives/signals';
 import { isObservable, lastValueFrom } from 'rxjs';
 import { ActivatedRoute } from '@angular/router';
 
-class EffectMap extends Map {
-    get(key, scope = 'host') {
-        return super.get(this.makeKey(key, scope));
-    }
-    set(key, value) {
-        return super.set(this.makeKey(key, value.props.scope), value);
+class NgAtomicActionLogger {
+    log(action, scope = 'default') {
+        console.info(`[NgAtomicActionLogger] ${action?.name}`, { action, scope });
     }
-    has(key, scope = 'host') {
-        return super.has(this.makeKey(key, scope));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicActionLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicActionLogger, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicActionLogger, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+const DEFAULT_EFFECT_PROPS = {
+    dispatch: false,
+    scopes: ['host'],
+    accessor: (action) => action.payload,
+};
+function normalizeEffectProps(props = {}) {
+    // If props has 'scope' but not 'scopes', convert scope to scopes array
+    const propsWithScopes = { ...props };
+    if ('scope' in props && !('scopes' in props)) {
+        propsWithScopes.scopes = props.scope ? [props.scope] : undefined;
+        delete propsWithScopes.scope;
     }
-    makeKey(key, scope = 'host') {
-        return `[${scope}]#${key}`;
+    const normalizedProps = merge({ ...DEFAULT_EFFECT_PROPS }, propsWithScopes);
+    // Ensure scopes is always an array
+    if (!normalizedProps.scopes || normalizedProps.scopes.length === 0) {
+        normalizedProps.scopes = ['host'];
     }
-}
-function Effect(id, { dispatch = false, scope = 'host', accessor = (action) => action.payload, } = {}) {
-    return function (target, propertyKey, descriptor) {
-        target['_effectMap'] ??= new EffectMap();
-        target['_effectMap'].set(id, { key: propertyKey, props: { dispatch, scope, accessor } });
-    };
+    return normalizedProps;
 }
 const EFFECT_ENTRY = new InjectionToken('[@ng-atomic/core] EFFECT_ENTRY');
-function provideEffect(ActionIds, _effectFactory, options = { dispatch: false }) {
+function provideEffectEntryMulti(useFactory) {
     return {
         provide: EFFECT_ENTRY,
-        useFactory: (injector) => {
-            return {
-                actionIds: ActionIds,
-                effectFactory: (hostInjector) => {
-                    return runInInjectionContext(hostInjector, () => {
-                        return _effectFactory(injector);
-                    });
-                },
-                options
-            };
-        },
+        useFactory,
         multi: true,
-        deps: [Injector]
+        deps: [Injector],
     };
 }
-function injectEffectReducer(injector = inject(Injector)) {
-    const effectEntries = injector.get(EFFECT_ENTRY, [], { optional: true });
-    const effectEntryMap = new Map();
-    for (const entry of effectEntries) {
-        const ids = Array.isArray(entry.actionIds) ? entry.actionIds : [entry.actionIds];
-        for (const id of ids) {
-            const effectFactory = () => entry.effectFactory(injector);
-            effectEntryMap.set(id, { effectFactory, options: entry.options });
+function provideEffect(ActionIds, _effectFactory, props) {
+    return provideEffectEntryMulti((factoryInjector) => ({
+        actionIds: ActionIds,
+        effectFactory: (host) => runInInjectionContext(host, () => _effectFactory(factoryInjector)),
+        props: normalizeEffectProps(props),
+    }));
+}
+function injectEffectEntries(injector = inject(Injector)) {
+    return injector.get(EFFECT_ENTRY, [], { optional: true }).map((entry) => ({
+        ...entry, context: { hostInjector: injector, scope: null }
+    }));
+}
+const EFFECT_ENTRIES_KEY = Symbol('_effectEntries_');
+function getEffectEntries(target) {
+    return target[EFFECT_ENTRIES_KEY] ??= [];
+}
+function Effect(actionId, props = {}) {
+    const normalizedProps = normalizeEffectProps(props);
+    return function (target, _, descriptor) {
+        getEffectEntries(target).push({
+            actionIds: [actionId],
+            props: normalizedProps,
+            effectFactory: () => (payload, context) => descriptor.value.call(context.component, payload),
+            context: { hostInjector: Injector.NULL }
+        });
+    };
+}
+class EffectResolver {
+    effectEntryMap = new Map();
+    register(effectEntry) {
+        const actionIds = Array.isArray(effectEntry.actionIds) ? effectEntry.actionIds : [effectEntry.actionIds];
+        for (const actionId of actionIds) {
+            for (const scope of effectEntry.props.scopes) {
+                const key = this.makeKey(actionId, scope);
+                this.effectEntryMap.set(key, {
+                    effectFactory: () => effectEntry.effectFactory(effectEntry.context.hostInjector),
+                    props: effectEntry.props,
+                });
+            }
         }
     }
-    return async (action, hostInjector) => {
-        const entry = effectEntryMap.get(action.id);
-        if (entry) {
-            await runInInjectionContext(hostInjector, () => {
-                const effect = entry?.effectFactory();
-                return effect(action.payload, { injector });
-            });
-            return { dispatch: false };
-        }
-        return { dispatch: true };
-    };
+    registerMany(entries) {
+        for (const entry of entries)
+            this.register(entry);
+    }
+    resolve(actionId, scope = 'host') {
+        return this.effectEntryMap.get(this.makeKey(actionId, scope));
+    }
+    makeKey(actionId, scope = 'host') {
+        return `[${scope}]#${actionId}`;
+    }
 }
-
-class NgAtomicActionLogger {
-    log(action, scope = 'default') {
-        console.info(`[NgAtomicActionLogger] ${action?.name}`, { action, scope });
+async function applyEffect(resolver, action, context) {
+    const entry = resolver.resolve(action.id, context.scope);
+    if (entry?.effectFactory) {
+        const effect = entry.effectFactory();
+        const payload = entry.props.accessor(action);
+        await effect(payload, context);
+        return { dispatch: entry.props.dispatch };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicActionLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicActionLogger, providedIn: 'root' });
+    return { dispatch: true };
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicActionLogger, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
+
 class NgAtomicRootActionStore {
     logger = inject(NgAtomicActionLogger);
-    _actions$ = new EventEmitter();
-    actions$ = this._actions$.asObservable();
+    actions$ = new EventEmitter();
+    resolver = new EffectResolver();
     constructor() {
-        this.actions$.subscribe(action => this.logger.log(action, 'root'));
+        this.actions$.pipe(takeUntilDestroyed()).subscribe(action => {
+            this.logger.log(action, 'root');
+            applyEffect(this.resolver, action, { component: null, scope: 'root' });
+        });
     }
-    dispatch(action) {
-        this._actions$.emit(action);
+    async dispatch(action) {
+        this.actions$.emit(action);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicRootActionStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicRootActionStore, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicRootActionStore, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [] });
-class NgAtomicInjectorActionStore {
-    logger = inject(NgAtomicActionLogger);
-    #rootActionStore = inject(NgAtomicRootActionStore);
-    async dispatch(injector, action, hostInjector = injector) {
-        const _action = { ...action, meta: { injector } };
-        this.logger.log(_action, 'injector');
-        const reducer = injectEffectReducer(injector);
-        const effect = await reducer(_action, hostInjector);
-        if (effect.dispatch) {
-            const injector_ = injector.get(Injector, null, { skipSelf: true });
-            if (injector_ && injector_ !== Injector.NULL) {
-                await this.dispatch(injector_, _action, hostInjector);
-            }
-            else {
-                await this.#rootActionStore.dispatch(_action);
-            }
-        }
+    register(effectEntry) {
+        this.resolver.register(effectEntry);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicInjectorActionStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicInjectorActionStore, providedIn: 'root' });
+    registerMany(effectEntries) {
+        this.resolver.registerMany(effectEntries);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicRootActionStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicRootActionStore, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicInjectorActionStore, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicRootActionStore, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [] });
 
 function resolveActions(actions, ...args) {
     if (typeof actions === 'function') {
@@ -178,6 +193,12 @@ function proxyFakeComputedInputValueFn(inputValueFn) {
 function computeFake(valueOrFakeComputed) {
     return isFakeComputed(valueOrFakeComputed) ? valueOrFakeComputed() : valueOrFakeComputed;
 }
+function isSignalOrFakeComputed(value) {
+    return isSignal(value) || isFakeComputed(value);
+}
+function computeFakeV2(valueOrFakeComputed) {
+    return isSignalOrFakeComputed(valueOrFakeComputed) ? computeFakeV2(valueOrFakeComputed()) : valueOrFakeComputed;
+}
 function proxyFakeComputedInputs(target, inputs) {
     inputs.filter(input => isSignal(target[input])).forEach(input => {
         target[input] = proxyFakeComputedInputValueFn(target[input]);
@@ -215,10 +236,10 @@ class CallPipe {
     transform(value) {
         return call(value);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: CallPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "19.1.4", ngImport: i0, type: CallPipe, isStandalone: true, name: "call" });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: CallPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "20.0.5", ngImport: i0, type: CallPipe, isStandalone: true, name: "call" });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: CallPipe, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: CallPipe, decorators: [{
             type: Pipe,
             args: [{ name: 'call', standalone: true, pure: true }]
         }] });
@@ -235,6 +256,9 @@ function provideComponent(abstract, typeOrFactory) {
     }
     return { provide: abstract[TOKEN], useValue: loadComponentType };
 }
+function makeProvideComopnentConfigure(abstract) {
+    return (typeOrFactory) => provideComponent(abstract, typeOrFactory);
+}
 function TokenizedType() {
     return function (type) {
         type[TOKEN] = new InjectionToken(type.name);
@@ -281,11 +305,8 @@ class InjectableComponent {
     #component = null;
     #componentMirror = null;
     injectable = input(false, { transform: (value) => value === '' ? true : value });
-    // readonly __action = ɵoutput<Action>({alias: 'action'});
-    __action = new EventEmitter();
-    dispatch(action) {
-        this.__action.emit(action);
-    }
+    // TOTO: 消すと一部のActionEffectが動かなくなる。おそらくバインディングの問題。
+    __action = output({ alias: 'action' });
     get #inputs() {
         return getInputs(this.constructor);
     }
@@ -319,12 +340,24 @@ class InjectableComponent {
     get propNames() {
         return this.#inputs.map(input => input.propName);
     }
+    get injected() {
+        return this.#component?.instance ?? null;
+    }
     proxyFakeComputedInputs() {
         proxyFakeComputedInputs(this, this.propNames);
     }
     #bindOutputs() {
         for (const output of this.#outputs) {
-            this.#component.instance[output.propName]?.pipe(takeUntilDestroyed(this.#destroyRef)).subscribe((value) => this[output.propName].emit(value));
+            const outputFn = this.#component.instance?.[output.propName];
+            if (!outputFn) {
+                continue;
+            }
+            else if (outputFn instanceof EventEmitter) {
+                outputFn.pipe(takeUntilDestroyed(this.#destroyRef)).subscribe((value) => this[output.propName].emit(value));
+            }
+            else {
+                outputFn.subscribe((value) => this[output.propName].emit(value));
+            }
         }
     }
     #bindEvents() {
@@ -373,19 +406,16 @@ class InjectableComponent {
             }
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: InjectableComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.1.4", type: InjectableComponent, isStandalone: true, inputs: { injectable: { classPropertyName: "injectable", publicName: "injectable", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { __action: "action" }, usesOnChanges: true, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: InjectableComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.0.5", type: InjectableComponent, isStandalone: true, inputs: { injectable: { classPropertyName: "injectable", publicName: "injectable", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { __action: "action" }, usesOnChanges: true, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: InjectableComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: InjectableComponent, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
                     // host: {ngSkipHydration: 'true'}
                 }]
-        }], ctorParameters: () => [], propDecorators: { __action: [{
-                type: Output,
-                args: ['action']
-            }] } });
+        }], ctorParameters: () => [] });
 
 function applyValueToInputField(instance, inputSignalNode, privateName, value) {
     if (inputSignalNode !== null) {
@@ -418,7 +448,11 @@ function updateInput(instance, propName, updater) {
 async function wrapLoadChildren(loadChildrenCallback) {
     const children = await loadChildrenCallback();
     const _children = isObservable(children) ? await lastValueFrom(children) : children;
-    const __children = 'default' in _children ? _children.default : _children;
+    const __children = 'default' in _children
+        ? _children.default
+        : 'routes' in _children
+            ? _children.routes
+            : _children;
     return __children;
 }
 function recursiveWrapRoute(route, ...wrappers) {
@@ -500,73 +534,101 @@ class DebugDirective {
         this.el.nativeElement.style.outlineOffset = '-1px';
         this.el.nativeElement.style.position = 'relative';
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DebugDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "19.1.4", type: DebugDirective, isStandalone: true, selector: "debug", inputs: { isDebug: { classPropertyName: "isDebug", publicName: "isDebug", isSignal: true, isRequired: false, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DebugDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.0.5", type: DebugDirective, isStandalone: true, selector: "debug", inputs: { isDebug: { classPropertyName: "isDebug", publicName: "isDebug", isSignal: true, isRequired: false, transformFunction: null }, label: { classPropertyName: "label", publicName: "label", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: DebugDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: DebugDirective, decorators: [{
             type: Directive,
             args: [{ standalone: true, selector: 'debug' }]
         }] });
 
-function injectIsRouteComponent(component) {
-    const route = inject(ActivatedRoute);
-    const currentComponent = route.snapshot.component;
-    return currentComponent === component.constructor;
+class NgAtomicHostActionStore {
+    logger = inject(NgAtomicActionLogger);
+    root = inject(NgAtomicRootActionStore);
+    appRef = inject(ApplicationRef);
+    route = inject(ActivatedRoute);
+    injector = inject(Injector);
+    async dispatch(action, context) {
+        this.logger.log(action, context.scope);
+        if (context.scope === 'root') {
+            return this.root.dispatch(action);
+        }
+        const resolver = new EffectResolver();
+        const entries = [...getEffectEntries(context?.component), ...injectEffectEntries(this.injector)];
+        resolver.registerMany(entries);
+        const result = await applyEffect(resolver, action, context);
+        if (!result.dispatch)
+            return;
+        if (this.isBootstrapOrRouteComponent(context)) {
+            return this.dispatchToParentInjector(action, context);
+        }
+        else {
+            return context.component.__action.emit(action);
+        }
+    }
+    async dispatchToParentInjector(action, context, injector = this.injector) {
+        this.logger.log(action, 'injector');
+        const parentInjector = injector.get(Injector, null, { skipSelf: true });
+        if (parentInjector && parentInjector !== Injector.NULL) {
+            const effectEntries = injectEffectEntries(parentInjector);
+            const resolver = new EffectResolver();
+            resolver.registerMany(effectEntries);
+            const result = await applyEffect(resolver, action, context);
+            if (result.dispatch) {
+                await this.dispatchToParentInjector(action, context, parentInjector);
+            }
+        }
+        else {
+            await this.root.dispatch(action);
+        }
+    }
+    isBootstrapOrRouteComponent(context) {
+        return this.isBootstrapComponent(context) || this.isRouteComponent(context);
+    }
+    isRouteComponent(context) {
+        return this.route.snapshot.component === context.component.constructor;
+    }
+    isBootstrapComponent(context) {
+        return this.appRef.components.some(component => component.instance === context.component);
+    }
+    registerRootEffectEntries(component) {
+        const entries = [...getEffectEntries(component), ...injectEffectEntries(this.injector)]
+            .filter(entry => entry.props.scopes.includes('root'));
+        this.root.registerMany(entries);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicHostActionStore, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.5", type: NgAtomicHostActionStore, isStandalone: true, ngImport: i0 });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicHostActionStore, decorators: [{
+            type: Directive,
+            args: [{ standalone: true }]
+        }] });
 class NgAtomicComponent extends InjectableComponent {
-    #rootActionStore = inject(NgAtomicRootActionStore);
-    #injectorActionStore = inject(NgAtomicInjectorActionStore);
-    #destroyRef = inject(DestroyRef);
-    #el = inject(ElementRef);
-    #injector = inject(Injector);
-    #logger = inject(NgAtomicActionLogger);
-    #isRouteComponent = injectIsRouteComponent(this);
-    #appRef = inject(ApplicationRef);
+    actionStore = inject(NgAtomicHostActionStore);
+    logger = inject(NgAtomicActionLogger);
     __injector = inject(Injector);
+    __action = output({ alias: 'action' });
+    #el = inject(ElementRef);
     get selector() {
         return this.#el.nativeElement.tagName.toLowerCase();
     }
-    get #isBootstrapComponent() {
-        return this.#appRef.components.some(component => component.instance === this);
-    }
     constructor() {
         super();
-        this.#rootActionStore.actions$.pipe(takeUntilDestroyed(this.#destroyRef)).subscribe(action => this.effect(action, 'root'));
-    }
-    async dispatch(action, scope = 'host', componentId = null) {
-        const _action = { ...action, meta: { componentId, selector: this.selector } };
-        this.#logger.log(_action, scope);
-        const dispatch = await this.effect(_action, scope);
-        if (dispatch) {
-            if (scope === 'root') {
-                return this.#rootActionStore.dispatch(_action);
-            }
-            else if (this.#isRouteComponent || this.#isBootstrapComponent) {
-                return this.#injectorActionStore.dispatch(this.#injector, _action);
-            }
-            else {
-                return super.dispatch(_action);
-            }
-        }
+        this.actionStore.registerRootEffectEntries(this);
     }
-    async effect(action, scope = 'host') {
-        // MEMO(@nontangent): _effectMapをpropertyに持つとEffectが機能しなくなる
-        const effectMap = (this['_effectMap'] ?? new EffectMap());
-        const effect = effectMap.get(action.id, scope);
-        if (effect?.key && effect?.props?.scope === scope) {
-            await this[effect.key](effect.props.accessor(action));
-            return !!effect?.props?.dispatch;
-        }
-        return true;
+    async dispatch(action_, scope = 'host', componentId = null) {
+        const action = { ...action_, meta: { componentId, selector: this.selector } };
+        return this.actionStore.dispatch(action, { component: this, scope });
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.1.4", type: NgAtomicComponent, isStandalone: true, usesInheritance: true, hostDirectives: [{ directive: DebugDirective }], ngImport: i0 });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicComponent, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.0.5", type: NgAtomicComponent, isStandalone: true, outputs: { __action: "action" }, usesInheritance: true, hostDirectives: [{ directive: NgAtomicHostActionStore }, { directive: DebugDirective }], ngImport: i0 });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImport: i0, type: NgAtomicComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NgAtomicComponent, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
                     hostDirectives: [
+                        NgAtomicHostActionStore,
                         DebugDirective,
                     ],
                 }]
@@ -576,5 +638,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.1.4", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { CallPipe, DebugDirective, EFFECT_ENTRY, Effect, EffectMap, FAKE_COMPUTED, HostType, InjectableComponent, NG_ATOMIC_DEBUG, NgAtomicActionLogger, NgAtomicComponent, NgAtomicInjectorActionStore, NgAtomicRootActionStore, TOKEN, TokenizedType, _computed, applyToInput, compute, computeFake, createAction, fakeComputed, getInputs, getInputsByComponentRef, getMeta, getOutputs, getOutputsByInstance, getToken, injectEffectReducer, isFakeComputed, provideComponent, provideEffect, proxyFakeComputedInputValueFn, proxyFakeComputedInputs, recursiveWrapRoute, recursiveWrapRoutes, resolveActions, updateInput, withNgAtomicDebug, wrapActions, wrapLoadChildren };
+export { CallPipe, DEFAULT_EFFECT_PROPS, DebugDirective, Effect, EffectResolver, FAKE_COMPUTED, HostType, InjectableComponent, NG_ATOMIC_DEBUG, NgAtomicActionLogger, NgAtomicComponent, NgAtomicHostActionStore, NgAtomicRootActionStore, TOKEN, TokenizedType, _computed, applyEffect, applyToInput, compute, computeFake, computeFakeV2, createAction, fakeComputed, getEffectEntries, getInputs, getInputsByComponentRef, getMeta, getOutputs, getOutputsByInstance, getToken, injectEffectEntries, isFakeComputed, isSignalOrFakeComputed, makeProvideComopnentConfigure, normalizeEffectProps, provideComponent, provideEffect, proxyFakeComputedInputValueFn, proxyFakeComputedInputs, recursiveWrapRoute, recursiveWrapRoutes, resolveActions, updateInput, withNgAtomicDebug, wrapActions, wrapLoadChildren };
 //# sourceMappingURL=ng-atomic-core.mjs.map