@ng-atomic/common 19.0.0-preview.9 → 19.1.1

package/services/spreadsheet/index.d.ts

@@ -1,4 +1,307 @@
-export * from './directives';
-export * from './features';
-export * from './models';
-export * from './spreadsheet.service';
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, AfterViewInit, ElementRef, OnDestroy } from '@angular/core';
+import * as _ng_atomic_common_utils from '@ng-atomic/common/utils';
+import * as _ng_atomic_common_pipes_data_accessor from '@ng-atomic/common/pipes/data-accessor';
+import { LanguageService } from '@ng-atomic/common/services/language';
+
+interface Cell {
+    dataValue: any;
+    expressionValue: any;
+}
+interface CellContext$1<I = any> {
+    item: I;
+    name: string;
+    position: Position$1;
+}
+interface Selection {
+    start: Position$1;
+    end: Position$1;
+}
+interface Position$1 {
+    row: number;
+    col: number;
+}
+
+declare class SpreadSheetDataService {
+    readonly displayedColumns: i0.WritableSignal<string[]>;
+    readonly items: i0.WritableSignal<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpreadSheetDataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpreadSheetDataService>;
+}
+
+declare class GridService {
+    protected readonly contextMap: Map<string, CellContext$1<any>>;
+    protected readonly data: SpreadSheetDataService;
+    readonly maxCol: i0.Signal<number>;
+    readonly maxRow: i0.Signal<number>;
+    setContext(context: CellContext$1): void;
+    getContext(position: Position$1): CellContext$1 | null;
+    protected buildKey(position: Position$1): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridService>;
+}
+
+declare class NavigationService {
+    private gridService;
+    moveToNextCell({ row, col }: Position$1): Position$1;
+    moveToPreviousCell({ row, col }: Position$1): Position$1;
+    moveToNextRow({ row, col }: Position$1): Position$1;
+    moveToPreviousRow({ row, col }: Position$1): Position$1;
+    moveRight(position: Position$1): Position$1;
+    moveLeft({ row, col }: Position$1): Position$1;
+    moveUp({ row, col }: Position$1): Position$1;
+    moveDown({ row, col }: Position$1): Position$1;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NavigationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NavigationService>;
+}
+
+declare class SelectionService {
+    protected readonly data: SpreadSheetDataService;
+    private readonly selection;
+    private readonly selectionStart;
+    private readonly isMouseDown;
+    private readonly grid;
+    private readonly cellElMap;
+    constructor();
+    isSelected(position: Position$1): boolean;
+    isCursorPosition(position: Position$1): boolean;
+    handleMouseDown(position: Position$1, event?: MouseEvent): void;
+    handleMouseUp(): void;
+    handleMouseEnter(position: Position$1): void;
+    handleClick(position: Position$1, event?: MouseEvent): void;
+    clearSelection(): void;
+    setStartPosition(position: Position$1): void;
+    getSelection(): Selection | null;
+    getSelectionEndOrStart(): Position$1;
+    updateSelectionEnd(position: Position$1): void;
+    private startSelection;
+    private updateSelection;
+    clearSelectedRange(selection: {
+        start: {
+            row: number;
+            col: number;
+        };
+        end: {
+            row: number;
+            col: number;
+        };
+    }): void;
+    setCell(position: Position$1, el: HTMLTableCellElement): void;
+    getCell(position: Position$1): HTMLTableCellElement | null;
+    focus(position: Position$1): void;
+    protected buildKey(position: Position$1): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionService>;
+}
+
+declare class ClipboardService {
+    private selectionService;
+    private clipboard;
+    private snackBar;
+    protected data: SpreadSheetDataService;
+    readonly dataAccessor: _ng_atomic_common_pipes_data_accessor.DataAccessor<unknown>;
+    readonly expression: _ng_atomic_common_utils.ExpressionTransformer;
+    readonly language: LanguageService;
+    constructor(selectionService: SelectionService);
+    private buildGridData;
+    copy(): Promise<void>;
+    setData(items: any[], displayedColumns: string[]): void;
+    protected copyText(text: string): void;
+    paste(targetRow: number, targetCol: number): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClipboardService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ClipboardService>;
+}
+
+declare class EditorService {
+    protected readonly data: SpreadSheetDataService;
+    private grid;
+    private selection;
+    private protection;
+    private editingStateManager;
+    readonly editinngCell: i0.WritableSignal<{
+        row: number;
+        col: number;
+    }>;
+    protected readonly inputMap: Map<string, HTMLInputElement>;
+    isEditing(position: Position$1): boolean;
+    startEditing(position: Position$1): void;
+    stopEditing(): void;
+    focus(position: Position$1): void;
+    getEditingCell(): Position$1 | null;
+    setInput(input: HTMLInputElement, position: Position$1): void;
+    getInput(position: Position$1): HTMLInputElement | null;
+    protected buildKey(position: Position$1): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EditorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EditorService>;
+}
+
+interface CellContext<T> {
+    item: T;
+    name: string;
+    position: {
+        row: number;
+        col: number;
+    };
+}
+type CellProtector = (value: any, context: CellContext<any>) => boolean;
+declare const COLUMN_PROTECTOR: InjectionToken<CellProtector[]>;
+declare function provideCellProtector(useFactory: () => CellProtector): {
+    provide: InjectionToken<CellProtector[]>;
+    useFactory: () => CellProtector;
+    multi: boolean;
+};
+declare class ProtectionService {
+    readonly protectors: CellProtector[];
+    isEditable(value: any, context: CellContext<any>): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProtectionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProtectionService>;
+}
+
+interface Range$1 {
+    start: Position$1;
+    end: Position$1;
+}
+declare class AutoFillService {
+    private autofillMode;
+    private sourcePosition;
+    private targetRange;
+    private previewElements;
+    readonly isAutofillMode: i0.Signal<boolean>;
+    readonly getSourcePosition: i0.Signal<Position$1>;
+    readonly getTargetRange: i0.Signal<Range$1>;
+    startAutofill(position: Position$1): void;
+    updateAutofillRange(endPosition: Position$1): void;
+    cancelAutofill(): void;
+    private updatePreview;
+    private clearPreview;
+    private getCellElement;
+    private resetAutofill;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AutoFillService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AutoFillService>;
+}
+
+declare class SpreadSheetService {
+    readonly config: {
+        paste: boolean;
+    };
+    readonly grid: GridService;
+    readonly navigation: NavigationService;
+    readonly selection: SelectionService;
+    readonly clipboard: ClipboardService;
+    readonly editor: EditorService;
+    readonly protection: ProtectionService;
+    readonly autofill: AutoFillService;
+    handleKeyDown(event: KeyboardEvent): void;
+    protected handleKeyDownOnEditing(event: KeyboardEvent): void;
+    protected handleKeyDownOnSelecting(event: KeyboardEvent): void;
+    protected move(_position: Position$1, dest: 'top' | 'bottom' | 'left' | 'right', mode: 'edit' | 'select'): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpreadSheetService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SpreadSheetService>;
+}
+declare function provideSpreadSheetService(): Provider[];
+
+declare class SpreadSheetCell implements AfterViewInit {
+    protected ss: SpreadSheetService;
+    readonly el: ElementRef<HTMLTableCellElement>;
+    readonly position: i0.InputSignal<{
+        row: number;
+        col: number;
+    }>;
+    readonly editable: i0.InputSignal<boolean>;
+    readonly context: i0.InputSignal<CellContext$1<any>>;
+    readonly isSelected: i0.Signal<boolean>;
+    readonly isEditing: i0.Signal<boolean>;
+    readonly frameEl: i0.WritableSignal<HTMLDivElement>;
+    constructor();
+    onDbClick(): void;
+    ngAfterViewInit(): void;
+    protected buildOutlineFrame(): HTMLDivElement;
+    protected createLabelElement(options: {
+        label: string;
+        color: string;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpreadSheetCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SpreadSheetCell, "[ssCell]", never, { "position": { "alias": "ssCell"; "required": false; "isSignal": true; }; "editable": { "alias": "ssCellEditable"; "required": false; "isSignal": true; }; "context": { "alias": "ssCellContext"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class SpreadSheetCellInput implements AfterViewInit {
+    protected ss: SpreadSheetService;
+    readonly position: i0.InputSignal<{
+        row: number;
+        col: number;
+    }>;
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly isSelected: i0.Signal<boolean>;
+    readonly isEditing: i0.Signal<boolean>;
+    ngAfterViewInit(): void;
+    protected stopEditing(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpreadSheetCellInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SpreadSheetCellInput, "[ssCellInput]", never, { "position": { "alias": "ssCellInput"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type Position = {
+    row: number;
+    col: number;
+};
+type Range = {
+    start: Position;
+    end: Position;
+};
+interface AutofillContext {
+    sourceContext: any;
+    targetContexts: Array<{
+        position: Position;
+        context: any;
+    }>;
+}
+/**
+ * テーブル全体のオートフィル機能を管理するディレクティブ
+ * セルディレクティブから直接呼び出される
+ */
+declare class GridDataTableAutofill implements OnDestroy {
+    private ss;
+    private viewContainerRef;
+    private renderer;
+    private autofillStartPosition;
+    private lastAutofillContexts;
+    private cleanupFunctions;
+    private handleComponent;
+    private currentCell;
+    readonly autofillComplete: i0.OutputEmitterRef<{
+        sourcePosition: Position;
+        targetRange: Range;
+        contexts: AutofillContext;
+    }>;
+    private currentPosition;
+    constructor();
+    showHandle(cell: HTMLElement, position: Position): void;
+    hideHandle(): void;
+    onAutofillStart(position: Position): void;
+    private setupScrollListener;
+    private startAutofill;
+    private onMouseMove;
+    private onMouseUp;
+    private completeAutofill;
+    getLastAutofillContexts(): AutofillContext | null;
+    private cleanup;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridDataTableAutofill, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridDataTableAutofill, "[gridDataTableAutofill]", never, {}, { "autofillComplete": "autofillComplete"; }, never, never, true, never>;
+}
+
+declare class SpreadSheetCellAutofill {
+    protected ss: SpreadSheetService;
+    readonly el: ElementRef<HTMLTableCellElement>;
+    readonly table: GridDataTableAutofill;
+    readonly position: i0.InputSignal<{
+        row: number;
+        col: number;
+    }>;
+    readonly enabled: i0.InputSignal<boolean>;
+    readonly shouldShow: i0.Signal<boolean>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpreadSheetCellAutofill, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SpreadSheetCellAutofill, "[gridDataCellAutofill]", never, { "position": { "alias": "gridDataCellAutofill"; "required": false; "isSignal": true; }; "enabled": { "alias": "gridDataCellAutofillEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { AutoFillService, COLUMN_PROTECTOR, ClipboardService, EditorService, GridDataTableAutofill, GridService, NavigationService, ProtectionService, SelectionService, SpreadSheetCell, SpreadSheetCellAutofill, SpreadSheetCellInput, SpreadSheetDataService, SpreadSheetService, provideCellProtector, provideSpreadSheetService };
+export type { AutofillContext, Cell, CellContext$1 as CellContext, CellProtector, Position$1 as Position, Range$1 as Range, Selection };

package/services/ui/index.d.ts

@@ -1,2 +1,104 @@
-export * from './ui.helpers';
-export * from './ui.service';
+import * as _ng_atomic_core from '@ng-atomic/core';
+import { Action } from '@ng-atomic/core';
+import * as rxjs from 'rxjs';
+import * as _ng_atomic_common_services_breakpoint from '@ng-atomic/common/services/breakpoint';
+import { Breakpoint, BreakpointService } from '@ng-atomic/common/services/breakpoint';
+import * as _angular_core from '@angular/core';
+import { Signal, InjectionToken, Injector, Provider, Type, ProviderToken } from '@angular/core';
+import * as _angular_router from '@angular/router';
+import { ActivatedRoute } from '@angular/router';
+import { RouterService } from '@ng-atomic/common/services/router';
+
+interface UIContext {
+    breakpoint: Breakpoint;
+    paths: any[];
+}
+declare class UiService {
+    readonly breakpoint: BreakpointService;
+    readonly router: RouterService;
+    readonly platformId: Object;
+    readonly paths$: rxjs.Observable<_angular_router.UrlSegment[]>;
+    readonly paths: _angular_core.Signal<_angular_router.UrlSegment[]>;
+    readonly snapshot$: rxjs.Observable<_angular_router.ActivatedRouteSnapshot>;
+    readonly snapshot: _angular_core.Signal<_angular_router.ActivatedRouteSnapshot>;
+    readonly uiContext: _angular_core.Signal<{
+        breakpoint: Breakpoint;
+        paths: _angular_router.UrlSegment[];
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<UiService>;
+}
+
+declare function scoped<T extends object, TKey extends keyof T>(source: Signal<T>, path: TKey | [TKey]): Signal<T[TKey]>;
+declare function injectBreakpoint(): Signal<_ng_atomic_common_services_breakpoint.Breakpoint>;
+declare function injectIsMobile(): Signal<boolean>;
+declare enum NavActionId {
+    TOGGLE_SIDE_NAV = "[@ng-atomic/common/services/ui] TOGGLE_SIDE_NAV",
+    BACK = "[@ng-atomic/common/services/ui] BACK",
+    CLOSE = "[@ng-atomic/common/services/ui] CLOSE"
+}
+declare function isRootPageRoute(route: ActivatedRoute, outlet?: string): boolean;
+declare function injectIsRootPage$(outlet?: string): rxjs.Observable<boolean>;
+declare function injectIsRootPage(outlet?: string): Signal<boolean>;
+declare function injectNavStartActions(isRootPage?: Signal<boolean>): Signal<Action[]>;
+declare function injectNavStartActionsV2(): Signal<Action<any>[]>;
+declare function injectSideAppNavStartActions(outlet?: string): Signal<Action[]>;
+declare function injectUiContext(): Signal<UIContext>;
+type UiConfigReducer<T extends object | string, C extends UIContext = any> = (config: T, context: C) => T;
+declare const UI_CONFIG_REDUCER: InjectionToken<UiConfigReducer<any, any>>;
+type ReducerFactory<T extends object | string> = (injector: Injector, hostInjector: Injector) => (config: T, context: UIContext) => T;
+type DefaultReducerFactory<T extends object | string> = (injector: Injector, hostInjector: Injector) => (context: UIContext) => T;
+declare const wrap: <T extends object | string>(defaultReducerFactory: DefaultReducerFactory<T>) => ReducerFactory<T>;
+declare function call<T>(signalOrValue: Signal<T> | T): T;
+declare function provideUiConfig<T extends object | string>(reducerFactory: ReducerFactory<T>, path?: string[], name?: string, token?: InjectionToken<UiConfigReducer<any, any>>): Provider;
+declare function injectRootConfig<T extends object>(paths?: string[], token?: InjectionToken<UiConfigReducer<any, any>>): Signal<T>;
+declare function injectUiConfig<T extends object>(paths?: string[], token?: InjectionToken<UiConfigReducer<any>>): Signal<T>;
+declare function makeConfig<T extends object>(defaultUseFactory: DefaultReducerFactory<T>, path: string[]): {
+    provide(useFactory?: ReducerFactory<T>, label?: string): Provider;
+    inject(): Signal<T>;
+};
+declare function makeDI<T extends object, K>(type: Type<K>, defaultUseFactory: DefaultReducerFactory<T>, path: string[]): {
+    provide: (typeOrComponent: Parameters<(typeOrFactory: _ng_atomic_core.TypeOrTypeFactory<any>) => {
+        provide: any;
+        useValue: () => Promise<Type<any>>;
+    }>[0]) => (Provider | {
+        provide: any;
+        useValue: () => Promise<Type<any>>;
+    })[];
+    provideConfig: (useFactory?: ReducerFactory<T>, label?: string) => Provider;
+    injectConfig: () => Signal<T>;
+    provideInitializer: <SI extends (store: K) => Promise<void> | void>(initializer: SI) => {
+        provide: InjectionToken<(store: any) => Promise<void> | void>;
+        useValue: {
+            key: new () => K;
+            initializer: (store: K) => Promise<void> | void;
+        };
+        multi: boolean;
+    }[];
+    initialize: (store: K) => Promise<void>;
+    provideComponent: (typeOrFactory: _ng_atomic_core.TypeOrTypeFactory<any>) => {
+        provide: any;
+        useValue: () => Promise<Type<any>>;
+    };
+    Initializer: {
+        provide<SI extends (store: K) => Promise<void> | void>(initializer: SI): {
+            provide: InjectionToken<(store: any) => Promise<void> | void>;
+            useValue: {
+                key: new () => K;
+                initializer: (store: K) => Promise<void> | void;
+            };
+            multi: boolean;
+        }[];
+        inject(): ((store: K) => Promise<void> | void)[];
+        initializeStore(store: K): Promise<void>;
+    };
+    Config: {
+        provide(useFactory?: ReducerFactory<T>, label?: string): Provider;
+        inject(): Signal<T>;
+    };
+};
+declare function injectDeepMulti<T>(token: ProviderToken<T>, injector?: Injector): T[];
+declare function debugInjector(injector?: Injector | null): void;
+
+export { NavActionId, UI_CONFIG_REDUCER, UiService, call, debugInjector, injectBreakpoint, injectDeepMulti, injectIsMobile, injectIsRootPage, injectIsRootPage$, injectNavStartActions, injectNavStartActionsV2, injectRootConfig, injectSideAppNavStartActions, injectUiConfig, injectUiContext, isRootPageRoute, makeConfig, makeDI, provideUiConfig, scoped, wrap };
+export type { DefaultReducerFactory, ReducerFactory, UIContext, UiConfigReducer };

package/stores/entities/index.d.ts

@@ -1,6 +1,169 @@
-export * from './di';
-export * from './entity-store-adapter';
-export * from './entity-store-manager';
-export * from './entity-store';
-export * from './proxy-id.service';
-export * from './task-composer';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injector, Signal } from '@angular/core';
+import { Type, BaseResolver } from '@nx-ddd/common/domain';
+import * as rxjs from 'rxjs';
+import { Observable, ReplaySubject, Subject } from 'rxjs';
+import * as _ngrx_entity_src_models from '@ngrx/entity/src/models';
+import { ComponentStore } from '@ngrx/component-store';
+import { EntityState, EntityAdapter } from '@ngrx/entity';
+
+declare class ProxyIdService {
+    proxyMap: Map<string, string>;
+    isProxyId(id: string | null): boolean;
+    proxyId(_id: string): string;
+    update(proxyId: string, id: string): void;
+    resolve(proxyIdOrId: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProxyIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProxyIdService>;
+}
+
+type Entity = {
+    id: string;
+};
+interface BaseTask {
+    type: 'create' | 'update' | 'delete' | 'noop';
+    timestamp: number;
+}
+interface CreateAction<T extends Entity> extends BaseTask {
+    type: 'create';
+    payload: T;
+}
+interface UpdateAction<T extends Entity> extends BaseTask {
+    type: 'update';
+    payload: Partial<T> & Entity;
+}
+interface DeleteAction extends BaseTask {
+    type: 'delete';
+    payload: Entity;
+}
+interface NoopAction extends BaseTask {
+    type: 'noop';
+    payload: {};
+}
+type Task<T extends Entity> = CreateAction<T> | UpdateAction<T> | DeleteAction | NoopAction;
+declare function pushMap<T>(map: Map<string, T[]>, id: string, item: T): Map<string, T[]>;
+declare class TaskComposerService {
+    readonly proxyId: ProxyIdService;
+    composeTasks<T extends Entity>(tasks: Task<T>[]): Task<T>[];
+    compose<T extends Entity>(tasks: Task<T>[]): Task<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskComposerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TaskComposerService>;
+}
+
+declare class EntityStoreAdapter<E extends Entity> {
+    list?(): Observable<E[]>;
+    create?(entity: E): Promise<E>;
+    update?(entity: Partial<E> & Pick<E, 'id'>): Promise<void>;
+    delete?(entity: Pick<E, 'id'>): Promise<void>;
+    save?(entity: E): Promise<E>;
+}
+declare const ENTITY_STORE_ADAPTER: InjectionToken<{
+    entity: Type<Entity>;
+    adapter: EntityStoreAdapter<Entity>;
+}[]>;
+declare function provideEntityStoreAdapter<E extends Entity>(entity: Type<E>, adapterFactory: (injector: Injector) => EntityStoreAdapter<E>): {
+    provide: InjectionToken<{
+        entity: Type<Entity>;
+        adapter: EntityStoreAdapter<Entity>;
+    }[]>;
+    multi: boolean;
+    useFactory: (injector: Injector) => {
+        entity: Type<E>;
+        adapter: EntityStoreAdapter<E>;
+    };
+    deps: (typeof Injector)[];
+};
+declare function injectEntityStoreAdapter<E extends Entity>(entity: Type<E>): EntityStoreAdapter<E>;
+
+declare const distinctUntilChangedArray: <T>() => rxjs.MonoTypeOperatorFunction<T>;
+declare class BaseEntityStore<E extends Entity> extends ComponentStore<EntityState<E>> {
+    protected entity: Type<E>;
+    protected entityAdapter: EntityAdapter<E>;
+    protected adapter: EntityStoreAdapter<E>;
+    protected readonly refresh$: ReplaySubject<void>;
+    protected readonly selectors: _ngrx_entity_src_models.EntitySelectors<E, EntityState<E>>;
+    readonly all$: Observable<E[]>;
+    readonly all: i0.Signal<E[]>;
+    readonly total$: Observable<number>;
+    readonly total: i0.Signal<number>;
+    /** @deprecated use BaseEntityStore.all$ instead. */
+    readonly entities$: Observable<E[]>;
+    /** @deprecated use BaseEntityStore.all instead. */
+    readonly entities: i0.Signal<E[]>;
+    /** @deprecated use BaseEntityStore.total$ instead. */
+    readonly size$: Observable<number>;
+    readonly addOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
+    readonly addMany: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
+    readonly updateOne: (observableOrValue: {
+        id: string;
+        changes: Partial<E>;
+    } | Observable<{
+        id: string;
+        changes: Partial<E>;
+    }>) => rxjs.Subscription;
+    readonly updateMany: (observableOrValue: {
+        id: string;
+        changes: Partial<E>;
+    }[] | Observable<{
+        id: string;
+        changes: Partial<E>;
+    }[]>) => rxjs.Subscription;
+    readonly upsertOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
+    readonly upsertMany: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
+    readonly removeOne: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    readonly removeMany: (observableOrValue: string[] | Observable<string[]>) => rxjs.Subscription;
+    readonly removeAll: () => void;
+    readonly setOne: E extends void ? () => void : (observableOrValue: E | Observable<E>) => rxjs.Subscription;
+    readonly setAll: (observableOrValue: E[] | Observable<E[]>) => rxjs.Subscription;
+    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
+    protected getEntities: (observableOrValue?: void | Observable<void>) => rxjs.Subscription;
+    refresh(): void;
+    mapToOne(valueOrObs: string | Observable<string>): Observable<E>;
+}
+declare class EntityStore<E extends Entity> extends BaseEntityStore<E> {
+    protected entity: Type<E>;
+    protected entityAdapter: EntityAdapter<E>;
+    protected proxyId: ProxyIdService;
+    protected composer: TaskComposerService;
+    protected taskSubject$: Subject<Task<E>>;
+    protected task$: Observable<Task<E>>;
+    protected composedTasks$: Observable<Task<E>[]>;
+    constructor(entity: Type<E>, entityAdapter?: EntityAdapter<E>);
+    dispatch(action: Task<E>): void;
+    protected runTask(task: Task<E>): Promise<any>;
+    protected runComposedTasks(tasks: Task<E>[]): Promise<void>;
+    protected onSyncFailed(): void;
+    protected onSyncSucceeded(): void;
+    create(payload: E): Promise<E>;
+    update(payload: Pick<E, 'id'> & Partial<E>): Promise<void>;
+    delete(payload: Pick<E, 'id'>): Promise<void>;
+    save(payload: E): Promise<E>;
+}
+
+type OneProps<V> = {
+    id: V;
+    [key: string]: V;
+};
+type AllProps<V> = {
+    [key: string]: V;
+};
+declare function injectOne$<T extends Entity>(Entity: Type<T>, params: OneProps<Observable<any>>, resolverType?: Type<BaseResolver<T>>): Observable<T>;
+declare function injectOne<T extends Entity>(Entity: Type<T>, params: OneProps<Signal<any>>, resolverType?: Type<BaseResolver<T>>): Signal<T>;
+declare function injectAll$<T extends Entity>(Entity: Type<T>, params?: Record<string, Observable<any>>, resolverType?: Type<BaseResolver<T>>): Observable<any[]>;
+declare const callSignalMap: <T extends Record<string, Signal<any>>>(map: T) => Signal<T>;
+declare function injectAll<T extends Entity>(Entity: Type<T>, params?: AllProps<Signal<any>>, resolverType?: Type<BaseResolver<T>>): Signal<T[]>;
+type ValueOrObservable<T> = T | Observable<T>;
+declare function mapToOne$<T extends {
+    id: string;
+}>(storeType: new () => EntityStore<T>, keyOrKey$: ValueOrObservable<string>): Observable<T>;
+
+declare class EntityStoreService {
+    protected storeMap: Map<Type<Entity>, EntityStore<Entity>>;
+    get<E extends Entity>(Entity: Type<E>): EntityStore<E>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityStoreService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EntityStoreService>;
+}
+declare function injectEntityStore<E extends Entity>(Entity: Type<E>): EntityStore<E>;
+
+export { BaseEntityStore, ENTITY_STORE_ADAPTER, EntityStore, EntityStoreAdapter, EntityStoreService, ProxyIdService, TaskComposerService, callSignalMap, distinctUntilChangedArray, injectAll, injectAll$, injectEntityStore, injectEntityStoreAdapter, injectOne, injectOne$, mapToOne$, provideEntityStoreAdapter, pushMap };
+export type { Entity, Task, ValueOrObservable };

package/stores/entity/index.d.ts

@@ -1 +1,31 @@
-export * from './entity.store';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+
+type Mode = 'create' | 'update';
+interface EntityState<Entity> {
+    mode: Mode;
+    entityId: string;
+    entity: Entity;
+}
+declare const tryCatch: (promise: Promise<any>) => Promise<unknown>;
+declare abstract class EntityStore<S extends EntityState<Entity>, Entity> extends ComponentStore<S> {
+    get entity(): Entity;
+    mode$: Observable<Mode>;
+    entityId$: Observable<string>;
+    entity$: Observable<Entity>;
+    setMode: (observableOrValue: Mode | Observable<Mode>) => rxjs.Subscription;
+    setEntityId: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    setEntity: Entity extends void ? () => void : (observableOrValue: Entity | Observable<Entity>) => rxjs.Subscription;
+    constructor(initialState?: S);
+    getEntityIdAndMode: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    getEntity: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    createEntity(value: Partial<Entity>): Promise<unknown>;
+    updateEntity(value: Partial<Entity>): Promise<void>;
+    abstract _getEntity(idOrParams: string): Observable<Entity>;
+    abstract _createEntity(entity: Entity): Promise<Entity>;
+    abstract _updateEntity(entity: Entity): Promise<void>;
+}
+
+export { EntityStore, tryCatch };
+export type { EntityState, Mode };

package/stores/pagination/index.d.ts

@@ -1 +1,24 @@
-export * from './pagination.store';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { ComponentStore } from '@ngrx/component-store';
+import { Page } from '@ng-atomic/common/utils';
+import * as i0 from '@angular/core';
+
+interface State {
+    page: Page;
+}
+declare class PaginationStore extends ComponentStore<State> {
+    constructor();
+    get page(): Page;
+    get start(): number;
+    get end(): number;
+    page$: Observable<Page>;
+    setPage: (observableOrValue: Page | Observable<Page>) => rxjs.Subscription;
+    patch: (observableOrValue: Partial<Page> | Observable<Partial<Page>>) => rxjs.Subscription;
+    getPageLength: (observableOrValue: any[] | Observable<any[]>) => rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationStore>;
+}
+
+export { PaginationStore };
+export type { State };

package/stores/query/index.d.ts

@@ -1 +1,22 @@
-export * from './query.store';
+import * as rxjs from 'rxjs';
+import { QueryResolverService } from '@ng-atomic/common/services/query-resolver';
+import { ComponentStore } from '@ngrx/component-store';
+import * as i0 from '@angular/core';
+
+interface QueryState {
+    query: string;
+}
+declare class QueryStore<E extends object = any> extends ComponentStore<QueryState> {
+    protected queryResolver: QueryResolverService<E>;
+    protected langMap: Record<string, string>;
+    constructor(queryResolver: QueryResolverService<E>, langMap: Record<string, string>);
+    get query(): string;
+    query$: rxjs.Observable<string>;
+    setQuery: (observableOrValue: string | rxjs.Observable<string>) => rxjs.Subscription;
+    resolve(entities: E[]): E[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryStore<any>, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QueryStore<any>>;
+}
+
+export { QueryStore };
+export type { QueryState };