@ngxs/store 3.8.2-dev.master-25397f3 → 3.8.2-dev.master-1a7514e

package/internals/custom-rxjs-subjects.d.ts

@@ -0,0 +1,42 @@
+import { BehaviorSubject, Subject } from 'rxjs';
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+export declare class ɵOrderedSubject<T> extends Subject<T> {
+    private _orderedNext;
+    next(value?: T): void;
+}
+/**
+ * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard BehaviorSubject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new BehaviorSubject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+export declare class ɵOrderedBehaviorSubject<T> extends BehaviorSubject<T> {
+    private _orderedNext;
+    private _currentValue;
+    constructor(value: T);
+    getValue(): T;
+    next(value: T): void;
+}

package/internals/index.d.ts

@@ -1,204 +1,9 @@
-import * as i0 from '@angular/core';
-import { InjectionToken, OnDestroy, Signal } from '@angular/core';
-import { ReplaySubject, Subject, BehaviorSubject } from 'rxjs';
-
-declare class StateToken<T = void> {
-    private readonly _name;
-    constructor(_name: ɵTokenName<T>);
-    getName(): string;
-    toString(): string;
-}
-
-interface ɵPlainObject {
-    [key: string]: any;
-}
-interface ɵPlainObjectOf<T> {
-    [key: string]: T;
-}
-type ɵStateClass<T = any> = new (...args: any[]) => T;
-declare const ɵMETA_KEY = "NGXS_META";
-declare const ɵMETA_OPTIONS_KEY = "NGXS_OPTIONS_META";
-declare const ɵSELECTOR_META_KEY = "NGXS_SELECTOR_META";
-interface ɵStateToken<T, U> {
-    new (name: ɵTokenName<T>): U;
-    getName(): string;
-    toString(): string;
-}
-type RequireGeneric<T, U> = T extends void ? 'You must provide a type parameter' : U;
-type ɵTokenName<T> = string & RequireGeneric<T, string>;
-type ɵExtractTokenType<P> = P extends StateToken<infer T> ? T : never;
-/**
- * Options that can be provided to the store.
- */
-interface ɵStoreOptions<T> {
-    /**
-     * Name of the state. Required.
-     */
-    name: string | StateToken<T>;
-    /**
-     * Default values for the state. If not provided, uses empty object.
-     */
-    defaults?: T;
-    /**
-     * Sub states for the given state.
-     *
-     * @deprecated
-     * Read the deprecation notice at this link: https://ngxs.io/deprecations/sub-states-deprecation.
-     */
-    children?: ɵStateClass[];
-}
-interface ɵStateClassInternal<T = any, U = any> extends ɵStateClass<T> {
-    [ɵMETA_KEY]?: ɵMetaDataModel;
-    [ɵMETA_OPTIONS_KEY]?: ɵStoreOptions<U>;
-}
-interface ɵMetaDataModel {
-    name: string | null;
-    actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;
-    defaults: any;
-    path: string | null;
-    makeRootSelector: ɵSelectorFactory | null;
-    /** @deprecated */
-    children?: ɵStateClassInternal[];
-}
-interface ɵSelectorMetaDataModel {
-    makeRootSelector: ɵSelectorFactory | null;
-    originalFn: Function | null;
-    containerClass: any;
-    selectorName: string | null;
-    getSelectorOptions: () => ɵSharedSelectorOptions;
-}
-interface ɵSharedSelectorOptions {
-    /**
-     * @deprecated
-     * Read the deprecation notice at this link: https://ngxs.io/deprecations/inject-container-state-deprecation.md.
-     */
-    injectContainerState?: boolean;
-    suppressErrors?: boolean;
-}
-interface ɵRuntimeSelectorContext {
-    getStateGetter(key: any): (state: any) => any;
-    getSelectorOptions(localOptions?: ɵSharedSelectorOptions): ɵSharedSelectorOptions;
-}
-type ɵSelectFromRootState = (rootState: any) => any;
-type ɵSelectorFactory = (runtimeContext: ɵRuntimeSelectorContext) => ɵSelectFromRootState;
-/**
- * Actions that can be provided in a action decorator.
- */
-interface ɵActionOptions {
-    /**
-     * Cancel the previous uncompleted observable(s).
-     */
-    cancelUncompleted?: boolean;
-}
-interface ɵActionHandlerMetaData {
-    fn: string | symbol;
-    options: ɵActionOptions;
-    type: string;
-}
-
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- */
-declare function ɵensureStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
-/**
- * Get the metadata attached to the state class if it exists.
- *
- * @ignore
- */
-declare function ɵgetStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
-/**
- * Ensures metadata is attached to the selector and returns it.
- *
- * @ignore
- */
-declare function ɵensureSelectorMetadata(target: Function): ɵSelectorMetaDataModel;
-/**
- * Get the metadata attached to the selector if it exists.
- *
- * @ignore
- */
-declare function ɵgetSelectorMetadata(target: any): ɵSelectorMetaDataModel;
-
-declare function defaultEqualityCheck(a: any, b: any): boolean;
-/**
- * Memoize a function on its last inputs only.
- * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
- *
- * @ignore
- */
-declare function ɵmemoize<T extends (...args: any[]) => any>(func: T, equalityCheck?: typeof defaultEqualityCheck): T;
-
-declare class ɵInitialState {
-    private static _value;
-    static set(state: ɵPlainObject): void;
-    static pop(): ɵPlainObject;
-}
-declare const ɵINITIAL_STATE_TOKEN: InjectionToken<ɵPlainObject>;
-
-declare class ɵNgxsAppBootstrappedState extends ReplaySubject<boolean> {
-    constructor();
-    bootstrap(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgxsAppBootstrappedState, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵNgxsAppBootstrappedState>;
-}
-
-declare const ɵNGXS_STATE_FACTORY: InjectionToken<any>;
-declare const ɵNGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;
-
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-declare class ɵOrderedSubject<T> extends Subject<T> {
-    private _orderedNext;
-    next(value?: T): void;
-}
-/**
- * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard BehaviorSubject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new BehaviorSubject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-declare class ɵOrderedBehaviorSubject<T> extends BehaviorSubject<T> {
-    private _orderedNext;
-    private _currentValue;
-    constructor(value: T);
-    getValue(): T;
-    next(value: T): void;
-}
-
-/**
- * BehaviorSubject of the entire state.
- * @ignore
- */
-declare class ɵStateStream extends ɵOrderedBehaviorSubject<ɵPlainObject> implements OnDestroy {
-    readonly state: Signal<ɵPlainObject>;
-    constructor();
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<ɵStateStream, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<ɵStateStream>;
-}
-
-export { StateToken, type ɵActionHandlerMetaData, type ɵActionOptions, type ɵExtractTokenType, ɵINITIAL_STATE_TOKEN, ɵInitialState, ɵMETA_KEY, ɵMETA_OPTIONS_KEY, type ɵMetaDataModel, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY, ɵNgxsAppBootstrappedState, ɵOrderedBehaviorSubject, ɵOrderedSubject, type ɵPlainObject, type ɵPlainObjectOf, type ɵRuntimeSelectorContext, ɵSELECTOR_META_KEY, type ɵSelectFromRootState, type ɵSelectorFactory, type ɵSelectorMetaDataModel, type ɵSharedSelectorOptions, type ɵStateClass, type ɵStateClassInternal, ɵStateStream, type ɵStateToken, type ɵStoreOptions, type ɵTokenName, ɵensureSelectorMetadata, ɵensureStoreMetadata, ɵgetSelectorMetadata, ɵgetStoreMetadata, ɵmemoize };
+export * from './symbols';
+export * from './metadata';
+export { ɵmemoize } from './memoize';
+export { StateToken } from './state-token';
+export { ɵINITIAL_STATE_TOKEN, ɵInitialState } from './initial-state';
+export { ɵNgxsAppBootstrappedState } from './ngxs-app-bootstrapped-state';
+export { ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY } from './internal-tokens';
+export { ɵOrderedSubject, ɵOrderedBehaviorSubject } from './custom-rxjs-subjects';
+export { ɵStateStream } from './state-stream';

package/internals/initial-state.d.ts

@@ -0,0 +1,8 @@
+import { InjectionToken } from '@angular/core';
+import { ɵPlainObject } from './symbols';
+export declare class ɵInitialState {
+    private static _value;
+    static set(state: ɵPlainObject): void;
+    static pop(): ɵPlainObject;
+}
+export declare const ɵINITIAL_STATE_TOKEN: InjectionToken<ɵPlainObject>;

package/internals/internal-tokens.d.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export declare const ɵNGXS_STATE_FACTORY: InjectionToken<any>;
+export declare const ɵNGXS_STATE_CONTEXT_FACTORY: InjectionToken<any>;

package/internals/memoize.d.ts

@@ -0,0 +1,9 @@
+declare function defaultEqualityCheck(a: any, b: any): boolean;
+/**
+ * Memoize a function on its last inputs only.
+ * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
+ *
+ * @ignore
+ */
+export declare function ɵmemoize<T extends (...args: any[]) => any>(func: T, equalityCheck?: typeof defaultEqualityCheck): T;
+export {};

package/internals/metadata.d.ts

@@ -0,0 +1,25 @@
+import { ɵMetaDataModel, ɵStateClassInternal, ɵSelectorMetaDataModel } from './symbols';
+/**
+ * Ensures metadata is attached to the class and returns it.
+ *
+ * @ignore
+ */
+export declare function ɵensureStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
+/**
+ * Get the metadata attached to the state class if it exists.
+ *
+ * @ignore
+ */
+export declare function ɵgetStoreMetadata(target: ɵStateClassInternal): ɵMetaDataModel;
+/**
+ * Ensures metadata is attached to the selector and returns it.
+ *
+ * @ignore
+ */
+export declare function ɵensureSelectorMetadata(target: Function): ɵSelectorMetaDataModel;
+/**
+ * Get the metadata attached to the selector if it exists.
+ *
+ * @ignore
+ */
+export declare function ɵgetSelectorMetadata(target: any): ɵSelectorMetaDataModel;

package/internals/ngxs-app-bootstrapped-state.d.ts

@@ -0,0 +1,8 @@
+import { ReplaySubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ɵNgxsAppBootstrappedState extends ReplaySubject<boolean> {
+    constructor();
+    bootstrap(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵNgxsAppBootstrappedState, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵNgxsAppBootstrappedState>;
+}

package/internals/state-stream.d.ts

@@ -0,0 +1,15 @@
+import { OnDestroy, Signal } from '@angular/core';
+import { ɵPlainObject } from './symbols';
+import { ɵOrderedBehaviorSubject } from './custom-rxjs-subjects';
+import * as i0 from "@angular/core";
+/**
+ * BehaviorSubject of the entire state.
+ * @ignore
+ */
+export declare class ɵStateStream extends ɵOrderedBehaviorSubject<ɵPlainObject> implements OnDestroy {
+    readonly state: Signal<ɵPlainObject>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ɵStateStream, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ɵStateStream>;
+}

package/internals/state-token.d.ts

@@ -0,0 +1,7 @@
+import type { ɵTokenName } from './symbols';
+export declare class StateToken<T = void> {
+    private readonly _name;
+    constructor(_name: ɵTokenName<T>);
+    getName(): string;
+    toString(): string;
+}

package/internals/symbols.d.ts

@@ -0,0 +1,88 @@
+import type { StateToken } from './state-token';
+export interface ɵPlainObject {
+    [key: string]: any;
+}
+export interface ɵPlainObjectOf<T> {
+    [key: string]: T;
+}
+export type ɵStateClass<T = any> = new (...args: any[]) => T;
+export declare const ɵMETA_KEY = "NGXS_META";
+export declare const ɵMETA_OPTIONS_KEY = "NGXS_OPTIONS_META";
+export declare const ɵSELECTOR_META_KEY = "NGXS_SELECTOR_META";
+export interface ɵStateToken<T, U> {
+    new (name: ɵTokenName<T>): U;
+    getName(): string;
+    toString(): string;
+}
+type RequireGeneric<T, U> = T extends void ? 'You must provide a type parameter' : U;
+export type ɵTokenName<T> = string & RequireGeneric<T, string>;
+export type ɵExtractTokenType<P> = P extends StateToken<infer T> ? T : never;
+/**
+ * Options that can be provided to the store.
+ */
+export interface ɵStoreOptions<T> {
+    /**
+     * Name of the state. Required.
+     */
+    name: string | StateToken<T>;
+    /**
+     * Default values for the state. If not provided, uses empty object.
+     */
+    defaults?: T;
+    /**
+     * Sub states for the given state.
+     *
+     * @deprecated
+     * Read the deprecation notice at this link: https://ngxs.io/deprecations/sub-states-deprecation.
+     */
+    children?: ɵStateClass[];
+}
+export interface ɵStateClassInternal<T = any, U = any> extends ɵStateClass<T> {
+    [ɵMETA_KEY]?: ɵMetaDataModel;
+    [ɵMETA_OPTIONS_KEY]?: ɵStoreOptions<U>;
+}
+export interface ɵMetaDataModel {
+    name: string | null;
+    actions: ɵPlainObjectOf<ɵActionHandlerMetaData[]>;
+    defaults: any;
+    path: string | null;
+    makeRootSelector: ɵSelectorFactory | null;
+    /** @deprecated */
+    children?: ɵStateClassInternal[];
+}
+export interface ɵSelectorMetaDataModel {
+    makeRootSelector: ɵSelectorFactory | null;
+    originalFn: Function | null;
+    containerClass: any;
+    selectorName: string | null;
+    getSelectorOptions: () => ɵSharedSelectorOptions;
+}
+export interface ɵSharedSelectorOptions {
+    /**
+     * @deprecated
+     * Read the deprecation notice at this link: https://ngxs.io/deprecations/inject-container-state-deprecation.md.
+     */
+    injectContainerState?: boolean;
+    suppressErrors?: boolean;
+}
+export interface ɵRuntimeSelectorContext {
+    getStateGetter(key: any): (state: any) => any;
+    getSelectorOptions(localOptions?: ɵSharedSelectorOptions): ɵSharedSelectorOptions;
+}
+export type ɵSelectFromRootState = (rootState: any) => any;
+export type ɵSelectorFactory = (runtimeContext: ɵRuntimeSelectorContext) => ɵSelectFromRootState;
+/**
+ * Actions that can be provided in a action decorator.
+ */
+export interface ɵActionOptions {
+    /**
+     * Cancel the previous uncompleted observable(s).
+     */
+    cancelUncompleted?: boolean;
+}
+export interface ɵActionHandlerMetaData {
+    fn: string | symbol;
+    options: ɵActionOptions;
+    type: string;
+}
+export {};

package/internals/testing/fresh-platform.d.ts

@@ -0,0 +1 @@
+export declare function freshPlatform(fn: (done?: VoidFunction) => Promise<void>): () => Promise<void>;

package/internals/testing/helpers/ngxs-test.component.d.ts

@@ -0,0 +1,8 @@
+import { AfterViewInit, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NgxsTestComponent implements OnInit, AfterViewInit {
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsTestComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgxsTestComponent, "app-root", never, {}, {}, never, never, false, never>;
+}

package/internals/testing/helpers/ngxs-test.module.d.ts

@@ -0,0 +1,10 @@
+import { ApplicationRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./ngxs-test.component";
+import * as i2 from "@angular/platform-browser";
+export declare class NgxsTestModule {
+    static ngDoBootstrap(app: ApplicationRef): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxsTestModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxsTestModule, [typeof i1.NgxsTestComponent], [typeof i2.BrowserModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NgxsTestModule>;
+}

package/internals/testing/index.d.ts

@@ -1,28 +1,4 @@
-import { Store, NgxsModuleOptions } from '@ngxs/store';
-import { ModuleWithProviders } from '@angular/core';
-import { TestBedStatic } from '@angular/core/testing';
-import { ɵStateClass as _StateClass } from '@ngxs/store/internals';
-
-declare function freshPlatform(fn: (done?: VoidFunction) => Promise<void>): () => Promise<void>;
-
-interface NgxsOptionsTesting {
-    states?: _StateClass[];
-    ngxsOptions?: NgxsModuleOptions;
-    imports?: ModuleWithProviders<any>[];
-    before?: () => void;
-}
-interface NgxsTesting {
-    store: Store;
-    getTestBed: TestBedStatic;
-}
-
-declare class NgxsTestBed {
-    static configureTestingStates(options: NgxsOptionsTesting): NgxsTesting;
-    private static ngxsBootstrap;
-    private static resetTestBed;
-    private static createRootNode;
-}
-
-declare function skipConsoleLogging<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;
-
-export { NgxsTestBed, type NgxsTesting, freshPlatform, skipConsoleLogging };
+export { freshPlatform } from './fresh-platform';
+export { NgxsTestBed } from './ngxs.setup';
+export { skipConsoleLogging } from './skip-console-logging';
+export { NgxsTesting } from './symbol';

package/internals/testing/ngxs.setup.d.ts

@@ -0,0 +1,7 @@
+import { NgxsOptionsTesting, NgxsTesting } from './symbol';
+export declare class NgxsTestBed {
+    static configureTestingStates(options: NgxsOptionsTesting): NgxsTesting;
+    private static ngxsBootstrap;
+    private static resetTestBed;
+    private static createRootNode;
+}

package/internals/testing/skip-console-logging.d.ts

@@ -0,0 +1 @@
+export declare function skipConsoleLogging<T extends (...args: any[]) => any>(fn: T): ReturnType<T>;

package/internals/testing/symbol.d.ts

@@ -0,0 +1,14 @@
+import { NgxsModuleOptions, Store } from '@ngxs/store';
+import { ModuleWithProviders } from '@angular/core';
+import { TestBedStatic } from '@angular/core/testing';
+import { ɵStateClass } from '@ngxs/store/internals';
+export interface NgxsOptionsTesting {
+    states?: ɵStateClass[];
+    ngxsOptions?: NgxsModuleOptions;
+    imports?: ModuleWithProviders<any>[];
+    before?: () => void;
+}
+export interface NgxsTesting {
+    store: Store;
+    getTestBed: TestBedStatic;
+}

package/operators/append.d.ts

@@ -0,0 +1,5 @@
+import { NoInfer, StateOperator } from './types';
+/**
+ * @param items - Specific items to append to the end of an array
+ */
+export declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;

package/operators/compose.d.ts

@@ -0,0 +1,2 @@
+import { NoInfer, StateOperator } from './types';
+export declare function compose<T>(...operators: NoInfer<StateOperator<T>[]>): StateOperator<T>;

package/operators/iif.d.ts

@@ -0,0 +1,10 @@
+import { NoInfer, StateOperator } from './types';
+import { Predicate } from './utils';
+/**
+ * @param condition - Condition can be a plain boolean value or a function,
+ * that returns boolean, also this function can take a value as an argument
+ * to which this state operator applies
+ * @param trueOperatorOrValue - Any value or a state operator
+ * @param elseOperatorOrValue - Any value or a state operator
+ */
+export declare function iif<T>(condition: NoInfer<Predicate<T>> | boolean, trueOperatorOrValue: NoInfer<StateOperator<T> | T>, elseOperatorOrValue?: NoInfer<StateOperator<T> | T>): StateOperator<T>;

package/operators/index.d.ts

@@ -1,102 +1,14 @@
-type _NoInfer<T> = T extends infer S ? S : never;
 /**
- * Blocks the ability of the typescript inferrence engine to be able to use the provided type as part of
- * inferring any type parameters from this usage.
- * @example
- * Primarily used to wrap parameters of functions in order to prevent the TypeScript inferrence engine
- * from inferring a type parameter of the function from the value provided to this parameter.
- * This essentially blocks the Contravariance of the function (through its parameters) so that the
- * function type parameter is purely determined by the Covariant requirements of the function's return type.
- * This is key to creating `StateOperator`s that are typed based on their contextual usage and not on the arguments
- * provided to them. This is critical for type safety and intellisense for State Operators.
- * Here is an example of how this benefits a state operator:
- * ```ts
- * declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
- * declare function appendBad<T>(items: T[]): StateOperator<T[]>;
- *
- * interface AAA {
- *   foo?: boolean;
- *   bar?: boolean;
- * }
- *
- * // Works
- * // (T in append is correctly inferred as AAA)
- * patch<{ test: AAA[] }>({ test: append([{ foo: true }]) });
- *
- * // Incorrectly throws: Type 'AAA' is not assignable to type '{ foo: true; }'.ts(2322)
- * // (T in appendBad is incorrectly inferred as { foo: true; })
- * patch<{ test: AAA[] }>({ test: appendBad([{ foo: true }]) });
- * ```
- *
- */
-type NoInfer<T> = T extends (infer O)[] ? _NoInfer<O>[] : _NoInfer<T>;
-/**
- * IMPORTANT NOTE: This should not be used externally to the library, rather
- * the exported type `ExistingState<T>` should be used instead.
- *
- * Used to convert a type to its readonly form. This can be given any type, from
- * primitives to objects or arrays that could already be readonly or not.
- * This does not apply the readonly construct to nested objects, but only to the top level type.
- */
-type ɵAsReadonly<T> = T extends Readonly<infer O> ? (O extends T ? Readonly<T> : T) : T;
-/**
- * Represents the existing state that is passed into a `StateOperator` which should
- * not be modified but will be used to build the new state returned by the `StateOperator`.
- */
-type ExistingState<T> = T extends any ? ɵAsReadonly<T> : never;
-/**
- * This is a monotype unary function that is used to create a new state from an existing state.
- * A state operator is usually created by a function that is given some data
- * to integrate with the state and returns a state operator which integrates this data or instruction.
- *
- * In state management terminology this creator function is commonly referred to as a state operator
- * because it represents the operation to be performed. ie. `patch`, `append`, `insertItem`, `compose`, `iif`, etc.
- */
-type StateOperator<T> = (existing: ExistingState<T>) => T;
-
-/**
- * @param items - Specific items to append to the end of an array
- */
-declare function append<T>(items: NoInfer<T[]>): StateOperator<T[]>;
-
-declare function compose<T>(...operators: NoInfer<StateOperator<T>[]>): StateOperator<T>;
-
-type Predicate<T = any> = (value: T | Readonly<T>) => boolean;
-declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
-declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
-
-/**
- * @param condition - Condition can be a plain boolean value or a function,
- * that returns boolean, also this function can take a value as an argument
- * to which this state operator applies
- * @param trueOperatorOrValue - Any value or a state operator
- * @param elseOperatorOrValue - Any value or a state operator
- */
-declare function iif<T>(condition: NoInfer<Predicate<T>> | boolean, trueOperatorOrValue: NoInfer<StateOperator<T> | T>, elseOperatorOrValue?: NoInfer<StateOperator<T> | T>): StateOperator<T>;
-
-/**
- * @param value - Value to insert
- * @param [beforePosition] -  Specified index to insert value before, optional
- */
-declare function insertItem<T>(value: NoInfer<T>, beforePosition?: number): StateOperator<T[]>;
-
-type NotUndefined<T> = T extends undefined ? never : T;
-type ɵPatchSpec<T> = {
-    [P in keyof T]?: T[P] | StateOperator<NotUndefined<T[P]>>;
-};
-declare function patch<T extends Record<string, any>>(patchObject: NoInfer<ɵPatchSpec<T>>): StateOperator<T>;
-
-/**
- * @param selector - Index of item in the array or a predicate function
- * that can be provided in `Array.prototype.findIndex`
- * @param operatorOrValue - New value under the `selector` index or a
- * function that can be applied to an existing value
- */
-declare function updateItem<T>(selector: number | NoInfer<Predicate<T>>, operatorOrValue: NoInfer<T> | NoInfer<StateOperator<T>>): StateOperator<T[]>;
-
-/**
- * @param selector - index or predicate to remove an item from an array by
- */
-declare function removeItem<T>(selector: number | NoInfer<Predicate<T>>): StateOperator<T[]>;
-
-export { type ExistingState, type NoInfer, type Predicate, type StateOperator, append, compose, iif, insertItem, isPredicate, isStateOperator, patch, removeItem, updateItem, type ɵPatchSpec };
+ * @module
+ * @description
+ * Entry point for all public APIs of this package.
+ */
+export { append } from './append';
+export { compose } from './compose';
+export { iif } from './iif';
+export { insertItem } from './insert-item';
+export { patch, ɵPatchSpec } from './patch';
+export { isStateOperator, isPredicate, Predicate } from './utils';
+export { updateItem } from './update-item';
+export { removeItem } from './remove-item';
+export { ExistingState, NoInfer, StateOperator } from './types';

package/operators/insert-item.d.ts

@@ -0,0 +1,6 @@
+import { NoInfer, StateOperator } from './types';
+/**
+ * @param value - Value to insert
+ * @param [beforePosition] -  Specified index to insert value before, optional
+ */
+export declare function insertItem<T>(value: NoInfer<T>, beforePosition?: number): StateOperator<T[]>;