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

package/index.d.ts

@@ -1 +1,235 @@
-export * from './lib';
+import * as i0 from '@angular/core';
+import { OnInit, OnChanges, SimpleChanges, Type, ComponentRef, ElementRef, ApplicationRef, Injector, Provider, EventEmitter, InputSignal, Signal, computed, CreateComputedOptions, PipeTransform, InjectionToken } from '@angular/core';
+import { ClassConstructor } from 'class-transformer';
+import { JsonSchema } from 'json-schema-library';
+import { ActivatedRoute, LoadChildrenCallback, Routes, Route } from '@angular/router';
+
+interface Action<T = any> {
+    id: string;
+    payload?: T;
+    name?: string;
+    icon?: string;
+    color?: string;
+    disabled?: boolean;
+    children?: Action<T>[];
+    meta?: {
+        componentId?: string | number | null;
+    } | any;
+}
+type ActionsFactory<T = any> = (...args: any[]) => Action<T>[];
+/** @deprecated */
+type Actions = ActionsFactory | Action[];
+type NavActions = Action[][] | Action[];
+type ItemActions<T = any> = (item: T) => Action[];
+declare function resolveActions(actions: Actions, ...args: any[]): Action<any>[];
+declare function wrapActions(actions: Actions): ActionsFactory;
+interface CreateActionsOptions<P extends object = any> {
+    validator?: (item: P) => null | string | string[];
+    name?: string;
+    icon?: string;
+}
+type ActionFactory<P extends object = any> = (payload?: P, meta?: CreateActionsOptions) => Action<P>;
+declare function createAction<P extends object = any>(type: string, schema: JsonSchema | ClassConstructor<P>, options?: CreateActionsOptions<P>): {
+    validate: (item: P) => null | string | string[];
+    create: ActionFactory<P>;
+};
+
+declare class NgAtomicActionLogger {
+    log(action: Action, scope?: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicActionLogger, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgAtomicActionLogger>;
+}
+
+type TypeFactoryAsync<T> = () => Promise<Type<T>>;
+type TypeFactory<T> = () => (Type<T> | Promise<Type<T>>);
+type TypeOrTypeFactory<T> = Type<T> | TypeFactory<T>;
+declare const TOKEN = "\u0394tkn";
+declare function provideComponent<ABS = any, IMPL = any>(abstract: Type<ABS>, typeOrFactory: TypeOrTypeFactory<IMPL>): {
+    provide: any;
+    useValue: () => Promise<Type<IMPL>>;
+};
+declare function makeProvideComopnentConfigure<Store = any, Component = any>(abstract: Type<Store>): (typeOrFactory: TypeOrTypeFactory<Component>) => {
+    provide: any;
+    useValue: () => Promise<Type<Component>>;
+};
+declare function TokenizedType(): <T extends Type<any>>(type: T) => void;
+declare function getToken(type: Type<any>): any;
+declare enum HostType {
+    Dir = "\u0275dir",
+    Cmp = "\u0275cmp"
+}
+type IO = {
+    propName: string;
+    templateName: string;
+};
+declare function getMeta<T>(type: Type<T>): unknown;
+declare function getInputs<T>(type: Type<T>): IO[];
+declare function getOutputs<T>(type: Type<T>): IO[];
+declare function getInputsByComponentRef<T extends {} = any>(cmp: ComponentRef<T>): IO[];
+declare function getOutputsByInstance<T extends {} = any>(cmp: ComponentRef<T>): IO[];
+declare class InjectableComponent<T = any> implements OnInit, OnChanges {
+    #private;
+    readonly injectable: i0.InputSignalWithTransform<any, any>;
+    readonly __action: i0.OutputEmitterRef<Action<any>>;
+    get propNames(): string[];
+    get injected(): T | null;
+    proxyFakeComputedInputs(): void;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(simpleChanges: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InjectableComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InjectableComponent<any>, never, never, { "injectable": { "alias": "injectable"; "required": false; "isSignal": true; }; }, { "__action": "action"; }, never, never, true, never>;
+}
+
+declare class DebugDirective implements OnInit {
+    protected el: ElementRef<HTMLElement>;
+    protected platformId: Object;
+    protected isDebug: i0.InputSignal<boolean>;
+    protected label: i0.InputSignal<string>;
+    ngOnInit(): void;
+    protected createLabelElement(options: {
+        label: string;
+        color: string;
+    }): void;
+    protected createOutline(color: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DebugDirective, "debug", never, { "isDebug": { "alias": "isDebug"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgAtomicHostActionStore {
+    protected readonly logger: NgAtomicActionLogger;
+    readonly root: NgAtomicRootActionStore;
+    readonly appRef: ApplicationRef;
+    readonly route: ActivatedRoute;
+    readonly injector: Injector;
+    dispatch(action: Action, context: ActionContext): Promise<void>;
+    protected dispatchToParentInjector(action: Action, context: ActionContext, injector?: Injector): Promise<void>;
+    protected isBootstrapOrRouteComponent(context: ActionContext): boolean;
+    protected isRouteComponent(context: ActionContext): boolean;
+    protected isBootstrapComponent(context: ActionContext): boolean;
+    registerRootEffectEntries(component: NgAtomicComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicHostActionStore, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgAtomicHostActionStore, never, never, {}, {}, never, never, true, never>;
+}
+declare class NgAtomicComponent<T = any> extends InjectableComponent<T> {
+    #private;
+    protected readonly actionStore: NgAtomicHostActionStore;
+    protected readonly logger: NgAtomicActionLogger;
+    readonly __injector: Injector;
+    readonly __action: i0.OutputEmitterRef<Action<any>>;
+    get selector(): any;
+    constructor();
+    dispatch(action_: Action, scope?: string, componentId?: string | number | null): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgAtomicComponent<any>, never, never, {}, { "__action": "action"; }, never, never, true, [{ directive: typeof NgAtomicHostActionStore; inputs: {}; outputs: {}; }, { directive: typeof DebugDirective; inputs: {}; outputs: {}; }]>;
+}
+
+interface EffectProps {
+    dispatch: boolean;
+    scopes: string[];
+    accessor: (action: Action) => any;
+}
+declare const DEFAULT_EFFECT_PROPS: EffectProps;
+declare function normalizeEffectProps(props?: Partial<EffectProps & {
+    scope?: string;
+}>): {
+    dispatch: boolean;
+    scopes: string[];
+    accessor: (action: Action) => any;
+} & {
+    dispatch?: boolean;
+    scopes?: string[];
+    accessor?: (action: Action) => any;
+    scope?: string;
+};
+interface EffectContext {
+    hostInjector: Injector;
+}
+interface ActionContext {
+    scope: 'root' | 'host' | string;
+    component?: NgAtomicComponent;
+}
+type EffectFactory = (hostInjector?: Injector) => Effect;
+type EffectResult = {
+    dispatch: boolean;
+};
+interface EffectEntry {
+    actionIds: string | string[];
+    effectFactory?: EffectFactory;
+    props?: EffectProps;
+    context?: EffectContext;
+}
+interface ResolvedEffectEntry {
+    effectFactory: () => Effect;
+    props: EffectProps;
+}
+declare function provideEffect(ActionIds: string[] | string, _effectFactory: (factoryInjector: Injector) => Effect, props?: Partial<EffectProps & {
+    scope?: string;
+}>): Provider;
+declare function injectEffectEntries(injector?: Injector): {
+    context: {
+        hostInjector: Injector;
+        scope: any;
+    };
+    actionIds: string | string[];
+    effectFactory?: EffectFactory;
+    props?: EffectProps;
+}[];
+declare function getEffectEntries(target: any): EffectEntry[];
+type Effect = (payload?: any, context?: ActionContext) => any | Promise<any>;
+declare function Effect(actionId: string, props?: Partial<EffectProps & {
+    scope?: string;
+}>): (target: any, _: string, descriptor: PropertyDescriptor) => void;
+declare class EffectResolver {
+    protected readonly effectEntryMap: Map<string, ResolvedEffectEntry>;
+    register(effectEntry: EffectEntry): void;
+    registerMany(entries: EffectEntry[]): void;
+    resolve(actionId: string, scope?: string): ResolvedEffectEntry | null;
+    private makeKey;
+}
+declare function applyEffect(resolver: EffectResolver, action: Action, context: ActionContext): Promise<EffectResult>;
+
+declare class NgAtomicRootActionStore {
+    protected readonly logger: NgAtomicActionLogger;
+    protected readonly actions$: EventEmitter<Action<any>>;
+    protected readonly resolver: EffectResolver;
+    constructor();
+    dispatch(action: Action): Promise<void>;
+    register(effectEntry: EffectEntry): void;
+    registerMany(effectEntries: EffectEntry[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicRootActionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgAtomicRootActionStore>;
+}
+
+type InputSignalType<T> = T extends InputSignal<infer U> ? U : never;
+declare function applyToInput<T, K extends keyof T>(instance: T, propName: K, value: InputSignalType<T[K]>): void;
+declare function updateInput<T, K extends keyof T>(instance: T, propName: K, updater: (value: InputSignalType<T[K]>) => InputSignalType<T[K]>): void;
+
+declare function wrapLoadChildren(loadChildrenCallback: LoadChildrenCallback): Promise<Routes>;
+declare function recursiveWrapRoute(route: Route, ...wrappers: ((route: Route) => Route)[]): Route;
+declare function recursiveWrapRoutes(routes: Routes, ...wrappers: ((route: Route) => Route)[]): Routes;
+
+declare function proxyFakeComputedInputValueFn(inputValueFn: any): any;
+declare function computeFake<T>(valueOrFakeComputed: T): T;
+declare function isSignalOrFakeComputed<T>(value: any): value is (Signal<T> | ReturnType<typeof computed<T>>);
+declare function computeFakeV2<T>(valueOrFakeComputed: Signal<T> | T): T;
+declare function proxyFakeComputedInputs(target: any, inputs: string[]): void;
+declare const FAKE_COMPUTED: unique symbol;
+declare function compute(target: any, propName: string): void;
+declare function fakeComputed<T>(computation: () => T, options?: CreateComputedOptions<T>): T;
+declare function _computed<T>(computation: () => T, options?: CreateComputedOptions<T>): T;
+declare function isFakeComputed(_computed: any): _computed is ReturnType<typeof computed>;
+declare class CallPipe implements PipeTransform {
+    transform<T>(value: Signal<T> | T): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CallPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<CallPipe, "call", true>;
+}
+
+declare const NG_ATOMIC_DEBUG: InjectionToken<boolean>;
+declare function withNgAtomicDebug(): {
+    provide: InjectionToken<boolean>;
+    useValue: boolean;
+};
+
+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 };
+export type { Action, ActionContext, ActionFactory, Actions, ActionsFactory, CreateActionsOptions, EffectContext, EffectEntry, EffectProps, EffectResult, ItemActions, NavActions, TypeFactory, TypeFactoryAsync, TypeOrTypeFactory };

package/package.json

@@ -1,21 +1,12 @@
 {
   "name": "@ng-atomic/core",
-  "version": "19.0.0-preview.8",
+  "version": "19.1.0",
   "homepage": "https://github.com/xx-machina/plaform/tree/main/packages/@ng-atomic/core",
   "repository": {
     "type": "git",
     "url": "https://github.com/xx-machina/plaform.git"
   },
-  "peerDependencies": {
-    "@angular/core": "19.1.4",
-    "@angular/common": "19.1.4",
-    "@angular/router": "19.1.4",
-    "ajv": "^8.17.1",
-    "class-transformer": "^0.5.1",
-    "class-validator": "^0.14.0",
-    "json-schema-library": "^10.0.0-rc2",
-    "rxjs": "^7.8.0"
-  },
+  "peerDependencies": {},
   "dependencies": {
     "tslib": "^2.3.0"
   },

package/README.md

@@ -1,70 +0,0 @@
-# @ng-atomic/core
-`@ng-atomic/core` is a library that enables dependency injection for components.
-
-## Install
-```sh
-$ npm i @ng-atomic/core
-```
-
-## Usage
-```ts
-import { Component, Directive, inject, input } from '@angular/core';
-import { bootstrapApplication } from '@angular/platform-browser';
-import { Effect, TokenizedType, provideComponent, InjectableComponent } from '@ng-atomic/core';
-import { NgAtomicComponent } from '@ng-atomic/core';
-import 'zone.js';
-
-export enum ActionId {
-  CREATE = 'Create',
-}
-
-@TokenizedType()
-@Directive({ standalone: true, selector: 'example' })
-export class ExampleComponentStore extends InjectableComponent {
-  static readonly ActionId = ActionId;
-  readonly name = input<string>('');
-}
-
-@Component({
-  standalone: true,
-  selector: `example`,
-  template: `
-  <div>{{ store.name() }}</div>
-  <button (click)="onClick()">ADD</button>
-  `,
-  hostDirectives: [
-    {
-      directive: ExampleComponentStore,
-      inputs: ['name'],
-    },
-  ],
-})
-export class ExampleComponent extends NgAtomicComponent {
-  protected readonly store = inject(ExampleComponentStore);
-
-  protected onClick() {
-    this.dispatch({ id: ActionId.CREATE, payload: 'ADD' });
-  }
-}
-
-@Component({
-  selector: 'app-root',
-  standalone: true,
-  imports: [ExampleComponentStore],
-  template: `
-    <example [name]="'test'" (action)="dispatch($event)" injectable/>
-  `,
-  providers: [provideComponent(ExampleComponentStore, () => ExampleComponent)],
-})
-export class App extends NgAtomicComponent {
-  @Effect(ExampleComponentStore.ActionId.CREATE)
-  protected create() {
-    alert('created!!');
-  }
-}
-
-bootstrapApplication(App);
-```
-
-# LISENCE
-MIT

package/lib/action-store.d.ts

@@ -1,24 +0,0 @@
-import { EventEmitter, Injector } from "@angular/core";
-import { Action } from "./action";
-import * as i0 from "@angular/core";
-export declare class NgAtomicActionLogger {
-    log(action: Action, scope?: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicActionLogger, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgAtomicActionLogger>;
-}
-export declare class NgAtomicRootActionStore {
-    protected logger: NgAtomicActionLogger;
-    protected readonly _actions$: EventEmitter<Action<any>>;
-    readonly actions$: import("rxjs").Observable<Action<any>>;
-    constructor();
-    dispatch(action: Action): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicRootActionStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgAtomicRootActionStore>;
-}
-export declare class NgAtomicInjectorActionStore {
-    #private;
-    protected logger: NgAtomicActionLogger;
-    dispatch(injector: Injector, action: Action, hostInjector?: Injector): Promise<void>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicInjectorActionStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<NgAtomicInjectorActionStore>;
-}

package/lib/action.d.ts

@@ -1,29 +0,0 @@
-import { ClassConstructor } from "class-transformer";
-import { JsonSchema } from "json-schema-library";
-export interface Action<T = any> {
-    id: string;
-    payload?: T;
-    name?: string;
-    icon?: string;
-    color?: string;
-    disabled?: boolean;
-    children?: Action<T>[];
-    meta?: {
-        componentId?: string | number | null;
-    } | any;
-}
-export type ActionsFactory<T = any> = (...args: any[]) => Action<T>[];
-/** @deprecated */
-export type Actions = ActionsFactory | Action[];
-export declare function resolveActions(actions: Actions, ...args: any[]): Action<any>[];
-export declare function wrapActions(actions: Actions): ActionsFactory;
-export interface CreateActionsOptions<P extends object = any> {
-    validator?: (item: P) => null | string | string[];
-    name?: string;
-    icon?: string;
-}
-export type ActionFactory<P extends object = any> = (payload?: P, meta?: CreateActionsOptions) => Action<P>;
-export declare function createAction<P extends object = any>(type: string, schema: JsonSchema | ClassConstructor<P>, options?: CreateActionsOptions<P>): {
-    validate: (item: P) => null | string | string[];
-    create: ActionFactory<P>;
-};

package/lib/debug/debug.directive.d.ts

@@ -1,16 +0,0 @@
-import { ElementRef, OnInit } from '@angular/core';
-import * as i0 from "@angular/core";
-export declare class DebugDirective implements OnInit {
-    protected el: ElementRef<HTMLElement>;
-    protected platformId: Object;
-    protected isDebug: import("@angular/core").InputSignal<boolean>;
-    protected label: import("@angular/core").InputSignal<string>;
-    ngOnInit(): void;
-    protected createLabelElement(options: {
-        label: string;
-        color: string;
-    }): void;
-    protected createOutline(color: string): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<DebugDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<DebugDirective, "debug", never, { "isDebug": { "alias": "isDebug"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/lib/debug/index.d.ts

@@ -1 +0,0 @@
-export * from './debug.directive';

package/lib/effect.d.ts

@@ -1,41 +0,0 @@
-import { InjectionToken, Injector, Provider } from "@angular/core";
-import { Action } from "./action";
-export interface EffectProps {
-    dispatch: boolean;
-    scope: string;
-    accessor: (action: Action) => any;
-}
-export declare class EffectMap extends Map<string, {
-    key: string;
-    props: EffectProps;
-}> {
-    get(key: string, scope?: string): {
-        key: string;
-        props: EffectProps;
-    };
-    set(key: string, value: {
-        key: string;
-        props: EffectProps;
-    }): this;
-    has(key: string, scope?: string): boolean;
-    private makeKey;
-}
-export declare function Effect(id: string, { dispatch, scope, accessor, }?: Partial<EffectProps>): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
-export interface EffectFunctionOptions {
-    dispatch?: boolean;
-}
-export interface EffectContext {
-    injector?: Injector;
-}
-export type EffectFunction = (payload?: any, context?: EffectContext) => any | Promise<any>;
-export type EffectFunctionFactory = (hostInjector?: Injector) => EffectFunction;
-export interface EffectEntry {
-    actionIds: string | string[];
-    effectFactory?: EffectFunctionFactory;
-    options?: EffectFunctionOptions;
-}
-export declare const EFFECT_ENTRY: InjectionToken<EffectEntry>;
-export declare function provideEffect(ActionIds: string[] | string, _effectFactory: (injector: Injector) => EffectFunction, options?: EffectFunctionOptions): Provider;
-export declare function injectEffectReducer(injector?: Injector): (action: Action, hostInjector: Injector) => Promise<{
-    dispatch: boolean;
-}>;

package/lib/index.d.ts

@@ -1,10 +0,0 @@
-export * from './action-store';
-export * from './action';
-export * from './effect';
-export * from './injectable-component';
-export * from './input';
-export * from './route';
-export * from './ng-atomic-component';
-export * from './signals';
-export * from './debug';
-export * from './ng-atomic-debug';

package/lib/injectable-component.d.ts

@@ -1,40 +0,0 @@
-import { ComponentRef, SimpleChanges, Type, EventEmitter } from "@angular/core";
-import { OnInit, OnChanges } from "@angular/core";
-import { Action } from "./action";
-import * as i0 from "@angular/core";
-export type TypeFactoryAsync<T> = () => Promise<Type<T>>;
-export type TypeFactory<T> = () => (Type<T> | Promise<Type<T>>);
-export declare const TOKEN = "\u0394tkn";
-export declare function provideComponent<ABS = any, IMPL = any>(abstract: Type<ABS>, typeOrFactory: Type<IMPL> | TypeFactory<IMPL>): {
-    provide: any;
-    useValue: () => Promise<Type<IMPL>>;
-};
-export declare function TokenizedType(): <T extends Type<any>>(type: T) => void;
-export declare function getToken(type: Type<any>): any;
-export declare enum HostType {
-    Dir = "\u0275dir",
-    Cmp = "\u0275cmp"
-}
-type IO = {
-    propName: string;
-    templateName: string;
-};
-export declare function getMeta<T>(type: Type<T>): unknown;
-export declare function getInputs<T>(type: Type<T>): IO[];
-export declare function getOutputs<T>(type: Type<T>): IO[];
-export declare function getInputsByComponentRef<T extends {} = any>(cmp: ComponentRef<T>): IO[];
-export declare function getOutputsByInstance<T extends {} = any>(cmp: ComponentRef<T>): IO[];
-export declare class InjectableComponent<T = any> implements OnInit, OnChanges {
-    #private;
-    readonly injectable: import("@angular/core").InputSignalWithTransform<any, any>;
-    readonly __action: EventEmitter<Action<any>>;
-    dispatch(action: Action): void;
-    get propNames(): string[];
-    proxyFakeComputedInputs(): void;
-    constructor();
-    ngOnInit(): void;
-    ngOnChanges(simpleChanges: SimpleChanges): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<InjectableComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InjectableComponent<any>, never, never, { "injectable": { "alias": "injectable"; "required": false; "isSignal": true; }; }, { "__action": "action"; }, never, never, true, never>;
-}
-export {};

package/lib/input.d.ts

@@ -1,5 +0,0 @@
-import { InputSignal } from '@angular/core';
-type InputSignalType<T> = T extends InputSignal<infer U> ? U : never;
-export declare function applyToInput<T, K extends keyof T>(instance: T, propName: K, value: InputSignalType<T[K]>): void;
-export declare function updateInput<T, K extends keyof T>(instance: T, propName: K, updater: (value: InputSignalType<T[K]>) => InputSignalType<T[K]>): void;
-export {};

package/lib/ng-atomic-component.d.ts

@@ -1,15 +0,0 @@
-import { Injector } from "@angular/core";
-import { Action } from "./action";
-import { InjectableComponent } from "./injectable-component";
-import * as i0 from "@angular/core";
-import * as i1 from "./debug/debug.directive";
-export declare class NgAtomicComponent<T = any> extends InjectableComponent<T> {
-    #private;
-    __injector: Injector;
-    get selector(): any;
-    constructor();
-    dispatch(action: Action, scope?: string, componentId?: string | number | null): Promise<void>;
-    protected effect(action: Action, scope?: string): Promise<boolean>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgAtomicComponent<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgAtomicComponent<any>, never, never, {}, {}, never, never, true, [{ directive: typeof i1.DebugDirective; inputs: {}; outputs: {}; }]>;
-}

package/lib/ng-atomic-debug.d.ts

@@ -1,6 +0,0 @@
-import { InjectionToken } from "@angular/core";
-export declare const NG_ATOMIC_DEBUG: InjectionToken<boolean>;
-export declare function withNgAtomicDebug(): {
-    provide: InjectionToken<boolean>;
-    useValue: boolean;
-};

package/lib/route.d.ts

@@ -1,4 +0,0 @@
-import { LoadChildrenCallback, Route, Routes } from '@angular/router';
-export declare function wrapLoadChildren(loadChildrenCallback: LoadChildrenCallback): Promise<Routes>;
-export declare function recursiveWrapRoute(route: Route, ...wrappers: ((route: Route) => Route)[]): Route;
-export declare function recursiveWrapRoutes(routes: Routes, ...wrappers: ((route: Route) => Route)[]): Routes;

package/lib/signals.d.ts

@@ -1,15 +0,0 @@
-import { CreateComputedOptions, Signal, computed, PipeTransform } from "@angular/core";
-import * as i0 from "@angular/core";
-export declare function proxyFakeComputedInputValueFn(inputValueFn: any): any;
-export declare function computeFake<T>(valueOrFakeComputed: T): T;
-export declare function proxyFakeComputedInputs(target: any, inputs: string[]): void;
-export declare const FAKE_COMPUTED: unique symbol;
-export declare function compute(target: any, propName: string): void;
-export declare function fakeComputed<T>(computation: () => T, options?: CreateComputedOptions<T>): T;
-export declare function _computed<T>(computation: () => T, options?: CreateComputedOptions<T>): T;
-export declare function isFakeComputed(_computed: any): _computed is ReturnType<typeof computed>;
-export declare class CallPipe implements PipeTransform {
-    transform<T>(value: Signal<T> | T): T;
-    static ɵfac: i0.ɵɵFactoryDeclaration<CallPipe, never>;
-    static ɵpipe: i0.ɵɵPipeDeclaration<CallPipe, "call", true>;
-}