ngxs-synchronizers 2.0.0 → 2.2.0

package/esm2022/decorators/sync-state.mjs

@@ -0,0 +1,61 @@
+import { Action, State } from "@ngxs/store";
+import { SyncClass } from "./sync-class";
+export function SyncState(options) {
+    return function (constructor) {
+        // Record the store options
+        SyncClass.setStoreOptions(constructor, options);
+        // Bootstrap the actions for the store
+        SyncState.UpdateAction.bootstrapClass(constructor);
+        // Record the parent store class for any child stores
+        if (options.children) {
+            options.children.forEach(child => SyncClass.setParent(child, constructor));
+        }
+        // Apply the @State() decorator to the class
+        State(options)(constructor);
+    };
+}
+(function (SyncState) {
+    class UpdateAction {
+        property;
+        payload;
+        static type;
+        constructor(property, payload) {
+            this.property = property;
+            this.payload = payload;
+        }
+    }
+    SyncState.UpdateAction = UpdateAction;
+    (function (UpdateAction) {
+        const UPDATE_ACTION_FN_KEY = Symbol("$UPDATE_ACTION_FN");
+        const updateActions = new Map();
+        function bootstrapClass($class) {
+            // Add the update action function to the class
+            Object.defineProperty($class.prototype, UPDATE_ACTION_FN_KEY, {
+                configurable: false,
+                enumerable: true,
+                value(context, { property, payload }) {
+                    if (context.getState() === undefined || context.getState() === null) {
+                        context.setState({ [property]: payload });
+                    }
+                    else {
+                        context.patchState({ [property]: payload });
+                    }
+                }
+            });
+            // Apply the @Action() decorator to the new function
+            Action(Type($class))($class.prototype, UPDATE_ACTION_FN_KEY, Object.getOwnPropertyDescriptor($class.prototype, UPDATE_ACTION_FN_KEY));
+        }
+        UpdateAction.bootstrapClass = bootstrapClass;
+        function Type($class) {
+            if (!updateActions.has($class)) {
+                const opts = SyncClass.getStoreOptions($class);
+                updateActions.set($class, class extends UpdateAction {
+                    static type = `[${opts.name} sync] Update field`;
+                });
+            }
+            return updateActions.get($class);
+        }
+        UpdateAction.Type = Type;
+    })(UpdateAction = SyncState.UpdateAction || (SyncState.UpdateAction = {}));
+})(SyncState || (SyncState = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/module.mjs

@@ -0,0 +1,20 @@
+import { NgModule } from "@angular/core";
+import { SyncStore } from "./sync-store";
+import * as i0 from "@angular/core";
+class NgxsSyncModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: NgxsSyncModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.1", ngImport: i0, type: NgxsSyncModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: NgxsSyncModule, providers: [
+            SyncStore
+        ] });
+}
+export { NgxsSyncModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: NgxsSyncModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        SyncStore
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL21vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxjQUFjLENBQUM7O0FBRXpDLE1BS2EsY0FBYzt1R0FBZCxjQUFjO3dHQUFkLGNBQWM7d0dBQWQsY0FBYyxhQUpaO1lBQ1AsU0FBUztTQUNaOztTQUVRLGNBQWM7MkZBQWQsY0FBYztrQkFMMUIsUUFBUTttQkFBQztvQkFDTixTQUFTLEVBQUU7d0JBQ1AsU0FBUztxQkFDWjtpQkFDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IFN5bmNTdG9yZSB9IGZyb20gXCIuL3N5bmMtc3RvcmVcIjtcblxuQE5nTW9kdWxlKHtcbiAgICBwcm92aWRlcnM6IFtcbiAgICAgICAgU3luY1N0b3JlXG4gICAgXVxufSlcbmV4cG9ydCBjbGFzcyBOZ3hzU3luY01vZHVsZSB7fVxuIl19

package/esm2022/state-selector.mjs

@@ -0,0 +1,224 @@
+import { BehaviorSubject, EMPTY, forkJoin, merge, of, throwError, zip } from "rxjs";
+import { catchError, distinctUntilChanged, filter, map, mergeMap, publishReplay, refCount, take, tap } from "rxjs/operators";
+import { SyncClass } from "./decorators/sync-class";
+import { SyncState } from "./decorators/sync-state";
+import { SynchronizerDictionary } from "./synchronizer/synchronizer-dictionary";
+export class StateSelector {
+    store;
+    stateClass;
+    state$;
+    synchronizers = SyncClass.getStoreOptions(this.stateClass).synchronizers;
+    injector = this.store.injector;
+    pendingRequests$ = new BehaviorSubject({});
+    constructor(store, stateClass, state$) {
+        this.store = store;
+        this.stateClass = stateClass;
+        this.state$ = state$;
+    }
+    dispatch(propertyName, value) {
+        const PropUpdateAction = SyncState.UpdateAction.Type(this.stateClass);
+        return this.store.dispatch(new PropUpdateAction(propertyName, value));
+    }
+    property(propertyName) {
+        return this.state$.pipe(map(state => state?.[propertyName]));
+    }
+    properties() {
+        return this.state$;
+    }
+    definedProperty(propertyName) {
+        return this.property(propertyName).pipe(filter((value) => value !== null && value !== undefined));
+    }
+    isSyncingProperty(propertyName) {
+        return this.getPropertyUpdater(propertyName).pipe(map(Boolean), distinctUntilChanged());
+    }
+    onPropertySyncing(propertyName) {
+        return this.isSyncingProperty(propertyName).pipe(filter(Boolean), map(() => propertyName));
+    }
+    onPropertySynced(propertyName) {
+        return this.isSyncingProperty(propertyName).pipe(filter(updating => !updating), map(() => propertyName));
+    }
+    onEveryPropertySyncing(...propertyNames) {
+        return zip(...propertyNames.map(propertyName => this.onPropertySyncing(propertyName)));
+    }
+    onEveryPropertySynced(...propertyNames) {
+        return zip(...propertyNames.map(propertyName => this.onPropertySynced(propertyName)));
+    }
+    onSomePropertySyncing(...propertyNames) {
+        return merge(...propertyNames.map(propertyName => this.onPropertySyncing(propertyName)));
+    }
+    onSomePropertySynced(...propertyNames) {
+        return merge(...propertyNames.map(propertyName => this.onPropertySynced(propertyName)));
+    }
+    require(propertyNames, options) {
+        if (Array.isArray(propertyNames)) {
+            return this.requireAll(propertyNames, options);
+        }
+        else {
+            return this.requireOne(propertyNames, options);
+        }
+    }
+    requireProperty(propertyName, options) {
+        return this.requireOne(propertyName, options).pipe(map(session => session[propertyName]));
+    }
+    sync(propertyNames, options) {
+        if (Array.isArray(propertyNames)) {
+            return this.syncAll(propertyNames, options);
+        }
+        else {
+            return this.syncOne(propertyNames, options);
+        }
+    }
+    syncProperty(propertyName, options) {
+        return this.syncOne(propertyName, options).pipe(map(session => session[propertyName]));
+    }
+    export(propertyNames, options) {
+        if (Array.isArray(propertyNames)) {
+            return this.exportAll(propertyNames, options);
+        }
+        else {
+            return this.exportOne(propertyNames, options);
+        }
+    }
+    requireOne(propertyName, options) {
+        return this.state$.pipe(take(1), mergeMap(state => {
+            if (state?.[propertyName] !== undefined && state?.[propertyName] !== null) {
+                return of(state);
+            }
+            else {
+                return this.sync(propertyName, options);
+            }
+        }));
+    }
+    requireAll(propertyNames, options) {
+        if (propertyNames.length === 0) {
+            return this.state$.pipe(take(1));
+        }
+        else {
+            const errors = [];
+            return forkJoin(propertyNames.map(propertyName => {
+                return this.requireOne(propertyName, options).pipe(catchError((error) => {
+                    errors.push(error);
+                    return of(undefined);
+                }));
+            })).pipe(mergeMap(() => {
+                if (errors.length === 0) {
+                    return this.state$.pipe(take(1));
+                }
+                else {
+                    return throwError(errors);
+                }
+            }));
+        }
+    }
+    syncOne(propertyName, options) {
+        options = options || {};
+        const errorPrefix = "[NGXS-Synchronizers] Cannot sync state:";
+        let synchronizer;
+        try {
+            synchronizer = this.resolveSynchronizer(propertyName);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+        // Check for cached values/pending requests only if this isn't a dependent requestor
+        if (!synchronizer.proxy) {
+            if (options.clearStore) {
+                // TODO-Synchronize on this?
+                this.dispatch(propertyName, undefined).subscribe();
+            }
+            if (synchronizer.requiredProperties && synchronizer.requiredProperties.some(requiredPropertyName => requiredPropertyName === propertyName)) {
+                return throwError(`${errorPrefix} Synchronizer for "${String(propertyName)}" requires a reference to itself.`);
+            }
+        }
+        return this.pendingRequests$.pipe(take(1), mergeMap((pendingRequests) => {
+            let pendingRequest$ = pendingRequests[propertyName];
+            if (pendingRequest$ && !options.clearStore) {
+                // Use the existing request if this value is currently being requested
+                return pendingRequest$;
+            }
+            else {
+                // First request any required fields needed to fetch the propertyName
+                if (synchronizer.proxy) {
+                    pendingRequest$ = this.syncAll(synchronizer.requiredProperties ?? [], options);
+                }
+                else {
+                    pendingRequest$ = this.requireAll(synchronizer.requiredProperties ?? []);
+                }
+                // Then fetch the propertyName
+                pendingRequest$ = pendingRequest$.pipe(mergeMap((requiredDetails) => synchronizer.read(requiredDetails, { propertyName, ...options })), mergeMap((value) => this.dispatch(propertyName, value)), // Update the store value
+                catchError((error) => {
+                    this.clearPropertyUpdater(propertyName, pendingRequest$);
+                    return throwError(error);
+                }), tap(() => this.clearPropertyUpdater(propertyName, pendingRequest$)), // Remove the pending request
+                mergeMap(() => this.state$.pipe(take(1))), // Get the newly updated state
+                publishReplay(1), refCount());
+                this.pendingRequests$.next(Object.assign(pendingRequests, { [propertyName]: pendingRequest$ }));
+                return pendingRequest$;
+            }
+        }));
+    }
+    syncAll(propertyNames, options) {
+        options = options || {};
+        if (propertyNames.length === 0) {
+            return this.state$.pipe(take(1));
+        }
+        // Update each required propertyName
+        const errors = [];
+        return forkJoin(propertyNames.map(name => this.sync(name, options).pipe(catchError((error) => {
+            errors.push(error);
+            return of(undefined);
+        })))).pipe(mergeMap(() => {
+            if (errors.length === 0) {
+                return this.state$.pipe(take(1));
+            }
+            else {
+                return throwError(`Error syncing properties: ${errors.join(", ")}`);
+            }
+        }));
+    }
+    exportOne(propertyName, options) {
+        options = options || {};
+        const errorPrefix = "[NGXS-Synchronizers] Cannot export state:";
+        let synchronizer;
+        try {
+            synchronizer = this.resolveSynchronizer(propertyName);
+        }
+        catch (error) {
+            return throwError(error);
+        }
+        if (!synchronizer.write) {
+            return throwError(`${errorPrefix} Synchronizer for "${String(propertyName)}" doesn't have a write method defined.`);
+        }
+        // Write the latest data in the store
+        return this.property(propertyName).pipe(take(1), mergeMap(data => synchronizer.write(data, { propertyName, ...options })), publishReplay(1), refCount());
+    }
+    exportAll(propertyNames, options) {
+        options = options || {};
+        if (propertyNames.length === 0) {
+            return EMPTY;
+        }
+        // Update each required propertyName
+        const errors = [];
+        return forkJoin(propertyNames.map(name => this.export(name, options).pipe(catchError((error) => {
+            errors.push(error);
+            return of(undefined);
+        })))).pipe(mergeMap((results) => {
+            if (errors.length === 0) {
+                return of(results);
+            }
+            else {
+                return throwError(`Error exporting properties: ${errors.join(", ")}`);
+            }
+        }));
+    }
+    getPropertyUpdater(propertyName) {
+        return this.pendingRequests$.pipe(map(pendingRequests => pendingRequests[propertyName]));
+    }
+    clearPropertyUpdater(propertyName, request) {
+        this.pendingRequests$.pipe(take(1), filter(pendingRequests => pendingRequests[propertyName] === request)).subscribe(pendingRequests => this.pendingRequests$.next(Object.assign(pendingRequests, { [propertyName]: undefined })));
+    }
+    resolveSynchronizer(propertyName) {
+        return SynchronizerDictionary.resolveSynchronizerInstance(this.injector, this.synchronizers ?? {}, propertyName);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state-selector.js","sourceRoot":"","sources":["../../src/state-selector.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { BehaviorSubject, EMPTY, forkJoin, merge, Observable, of, throwError, zip } from \"rxjs\";\nimport { catchError, distinctUntilChanged, filter, map, mergeMap, publishReplay, refCount, take, tap } from \"rxjs/operators\";\nimport { SyncClass } from \"./decorators/sync-class\";\nimport { SyncState } from \"./decorators/sync-state\";\nimport { SyncStore } from \"./sync-store\";\nimport { Synchronizer } from \"./synchronizer/synchronizer\";\nimport { SynchronizerDictionary } from \"./synchronizer/synchronizer-dictionary\";\n\ntype PendingStateRequestDictionary<T> = {\n    [P in keyof T]?: Observable<T>;\n};\n\nexport class StateSelector<T> {\n\n    public readonly synchronizers = SyncClass.getStoreOptions(this.stateClass).synchronizers;\n\n    private readonly injector = this.store.injector;\n    private readonly pendingRequests$ = new BehaviorSubject<PendingStateRequestDictionary<T>>({});\n\n    constructor(\n        private store: SyncStore,\n        private stateClass: SyncClass<T>,\n        private state$: Observable<T | undefined>\n    ) {}\n\n    public dispatch<PropT extends keyof T>(propertyName: PropT, value: T[PropT]): Observable<T> {\n        const PropUpdateAction = SyncState.UpdateAction.Type<T, PropT>(this.stateClass);\n\n        return this.store.dispatch(new PropUpdateAction(propertyName, value));\n    }\n\n    public property<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT] | undefined> {\n        return this.state$.pipe(map(state => state?.[propertyName]));\n    }\n\n    public properties(): Observable<T | undefined> {\n        return this.state$;\n    }\n\n    public definedProperty<PropT extends keyof T>(propertyName: PropT): Observable<T[PropT]> {\n        return this.property<PropT>(propertyName).pipe(\n            filter((value): value is T[PropT] => value !== null && value !== undefined)\n        );\n    }\n\n    public isSyncingProperty(propertyName: keyof T): Observable<boolean> {\n        return this.getPropertyUpdater(propertyName).pipe(\n            map(Boolean),\n            distinctUntilChanged()\n        );\n    }\n\n    public onPropertySyncing<PropT extends keyof T>(propertyName: PropT): Observable<PropT> {\n        return this.isSyncingProperty(propertyName).pipe(\n            filter(Boolean),\n            map(() => propertyName),\n        );\n    }\n\n    public onPropertySynced<PropT extends keyof T>(propertyName: PropT): Observable<PropT> {\n        return this.isSyncingProperty(propertyName).pipe(\n            filter(updating => !updating),\n            map(() => propertyName)\n        );\n    }\n\n    public onEveryPropertySyncing(...propertyNames: Array<keyof T>): Observable<Array<keyof T>> {\n        return zip(...propertyNames.map(propertyName => this.onPropertySyncing(propertyName)));\n    }\n\n    public onEveryPropertySynced(...propertyNames: Array<keyof T>): Observable<Array<keyof T>> {\n        return zip(...propertyNames.map(propertyName => this.onPropertySynced(propertyName)));\n    }\n\n    public onSomePropertySyncing(...propertyNames: Array<keyof T>): Observable<keyof T> {\n        return merge(...propertyNames.map(propertyName => this.onPropertySyncing(propertyName)));\n    }\n\n    public onSomePropertySynced(...propertyNames: Array<keyof T>): Observable<keyof T> {\n        return merge(...propertyNames.map(propertyName => this.onPropertySynced(propertyName)));\n    }\n\n    public require<RequestParamsT = never>(\n        propertyNames: keyof T | Array<keyof T>,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        if (Array.isArray(propertyNames)) {\n            return this.requireAll<RequestParamsT>(propertyNames, options);\n        } else {\n            return this.requireOne<keyof T, RequestParamsT>(propertyNames, options);\n        }\n    }\n\n    public requireProperty<PropT extends keyof T, RequestParamsT = never>(\n        propertyName: PropT,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T[PropT]> {\n        return this.requireOne<PropT, RequestParamsT>(propertyName, options).pipe(map(session => session[propertyName]));\n    }\n\n    public sync<RequestParamsT = never>(\n        propertyNames: keyof T | Array<keyof T>,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        if (Array.isArray(propertyNames)) {\n            return this.syncAll<RequestParamsT>(propertyNames, options);\n        } else {\n            return this.syncOne<keyof T, RequestParamsT>(propertyNames, options);\n        }\n    }\n\n    public syncProperty<PropT extends keyof T, RequestParamsT = never>(\n        propertyName: PropT,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T[PropT]> {\n        return this.syncOne<PropT, RequestParamsT>(propertyName, options).pipe(map(session => session[propertyName]));\n    }\n\n    public export<RequestParamsT = never>(\n        propertyNames: keyof T | Array<keyof T>,\n        options?: Synchronizer.WriteOptions<RequestParamsT>\n    ): Observable<any> {\n        if (Array.isArray(propertyNames)) {\n            return this.exportAll<RequestParamsT>(propertyNames, options);\n        } else {\n            return this.exportOne<keyof T, RequestParamsT>(propertyNames, options);\n        }\n    }\n\n    private requireOne<PropT extends keyof T, RequestParamsT = never>(\n        propertyName: PropT,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        return this.state$.pipe(\n            take(1),\n            mergeMap(state => {\n                if (state?.[propertyName] !== undefined && state?.[propertyName] !== null) {\n                    return of(state);\n                } else {\n                    return this.sync<RequestParamsT>(propertyName, options);\n                }\n            })\n        );\n    }\n\n    private requireAll<RequestParamsT = never>(\n        propertyNames: Array<keyof T>,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        if (propertyNames.length === 0) {\n            return this.state$.pipe(take<T | undefined>(1)) as Observable<T>;\n        } else {\n            const errors: any[] = [];\n            return forkJoin(propertyNames.map(propertyName => {\n                return this.requireOne<keyof T, RequestParamsT>(propertyName, options).pipe(\n                    catchError((error) => {\n                        errors.push(error);\n                        return of(undefined);\n                    })\n                );\n            })).pipe(\n                mergeMap(() => {\n                    if (errors.length === 0) {\n                        return this.state$.pipe(take<T | undefined>(1)) as Observable<T>;\n                    } else {\n                        return throwError(errors);\n                    }\n                })\n            );\n        }\n    }\n\n    private syncOne<PropT extends keyof T, RequestParamsT = never>(\n        propertyName: PropT,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        options = options || {};\n        const errorPrefix = \"[NGXS-Synchronizers] Cannot sync state:\";\n\n        let synchronizer: Synchronizer<T, PropT, RequestParamsT, never>;\n        try {\n            synchronizer = this.resolveSynchronizer(propertyName);\n        } catch (error) {\n            return throwError(error);\n        }\n\n        // Check for cached values/pending requests only if this isn't a dependent requestor\n        if (!synchronizer.proxy) {\n            if (options.clearStore) {\n                // TODO-Synchronize on this?\n                this.dispatch(propertyName, undefined!).subscribe();\n            }\n\n            if (synchronizer.requiredProperties && synchronizer.requiredProperties.some(requiredPropertyName => requiredPropertyName === propertyName)) {\n                return throwError(`${errorPrefix} Synchronizer for \"${String(propertyName)}\" requires a reference to itself.`);\n            }\n        }\n\n        return this.pendingRequests$.pipe(\n            take(1),\n            mergeMap((pendingRequests) => {\n                let pendingRequest$ = pendingRequests[propertyName] as Observable<T>;\n\n                if (pendingRequest$ && !options!.clearStore) {\n                    // Use the existing request if this value is currently being requested\n                    return pendingRequest$;\n                } else {\n                    // First request any required fields needed to fetch the propertyName\n                    if (synchronizer.proxy) {\n                        pendingRequest$ = this.syncAll<RequestParamsT>(synchronizer.requiredProperties ?? [], options);\n                    } else {\n                        pendingRequest$ = this.requireAll<RequestParamsT>(synchronizer.requiredProperties ?? []);\n                    }\n\n                    // Then fetch the propertyName\n                    pendingRequest$ = pendingRequest$.pipe(\n                        mergeMap((requiredDetails: any) => synchronizer.read(requiredDetails, { propertyName, ...options })),\n                        mergeMap((value: any) => this.dispatch(propertyName, value)), // Update the store value\n                        catchError((error) => {\n                            this.clearPropertyUpdater(propertyName, pendingRequest$!);\n                            return throwError(error);\n                        }),\n                        tap(() => this.clearPropertyUpdater(propertyName, pendingRequest$!)), // Remove the pending request\n                        mergeMap(() => this.state$.pipe(take<T | undefined>(1)) as Observable<T>), // Get the newly updated state\n                        publishReplay(1),\n                        refCount()\n                    );\n\n                    this.pendingRequests$.next(Object.assign(pendingRequests, { [propertyName]: pendingRequest$ }));\n                    return pendingRequest$;\n                }\n            })\n        );\n    }\n\n    private syncAll<RequestParamsT = never>(\n        propertyNames: Array<keyof T>,\n        options?: Synchronizer.ReadOptions<RequestParamsT>\n    ): Observable<T> {\n        options = options || {};\n\n        if (propertyNames.length === 0) {\n            return this.state$.pipe(take<T | undefined>(1)) as Observable<T>;\n        }\n\n        // Update each required propertyName\n        const errors: any[] = [];\n        return forkJoin(propertyNames.map(name => this.sync<RequestParamsT>(name, options).pipe(\n            catchError((error) => {\n                errors.push(error);\n                return of(undefined);\n            })))).pipe(\n                mergeMap(() => {\n                    if (errors.length === 0) {\n                        return this.state$.pipe(take<T | undefined>(1)) as Observable<T>;\n                    } else {\n                        return throwError(`Error syncing properties: ${errors.join(\", \")}`);\n                    }\n                })\n            );\n    }\n\n    private exportOne<PropT extends keyof T, RequestParamsT = never>(\n        propertyName: PropT,\n        options?: Synchronizer.WriteOptions<RequestParamsT>\n    ): Observable<any> {\n        options = options || {};\n        const errorPrefix = \"[NGXS-Synchronizers] Cannot export state:\";\n\n        let synchronizer: Synchronizer<T, PropT, never, RequestParamsT>;\n        try {\n            synchronizer = this.resolveSynchronizer(propertyName);\n        } catch (error) {\n            return throwError(error);\n        }\n\n        if (!synchronizer.write) {\n            return throwError(`${errorPrefix} Synchronizer for \"${String(propertyName)}\" doesn't have a write method defined.`);\n        }\n\n        // Write the latest data in the store\n        return this.property(propertyName).pipe(\n            take(1),\n            mergeMap(data => synchronizer.write!(data!, { propertyName, ...options })),\n            publishReplay(1),\n            refCount()\n        );\n    }\n\n    private exportAll<RequestParamsT = never>(\n        propertyNames: Array<keyof T>,\n        options?: Synchronizer.WriteOptions<RequestParamsT>\n    ): Observable<any> {\n        options = options || {};\n\n        if (propertyNames.length === 0) {\n            return EMPTY;\n        }\n\n        // Update each required propertyName\n        const errors: any[] = [];\n        return forkJoin(propertyNames.map(name => this.export<RequestParamsT>(name, options).pipe(\n            catchError((error) => {\n                errors.push(error);\n                return of(undefined);\n            })))).pipe(\n                mergeMap((results) => {\n                    if (errors.length === 0) {\n                        return of(results);\n                    } else {\n                        return throwError(`Error exporting properties: ${errors.join(\", \")}`);\n                    }\n                })\n            );\n    }\n\n    private getPropertyUpdater(propertyName: keyof T): Observable<Observable<T> | undefined> {\n        return this.pendingRequests$.pipe(map(pendingRequests => pendingRequests[propertyName]));\n    }\n\n    private clearPropertyUpdater(propertyName: keyof T, request: Observable<T>): void {\n        this.pendingRequests$.pipe(\n            take(1),\n            filter(pendingRequests => pendingRequests[propertyName] === request)\n        ).subscribe(pendingRequests => this.pendingRequests$.next(Object.assign(pendingRequests, { [propertyName]: undefined })));\n    }\n\n    private resolveSynchronizer<PropT extends keyof T, RequestParamsT>(propertyName: PropT): Synchronizer<T, PropT, RequestParamsT, RequestParamsT> {\n        return SynchronizerDictionary.resolveSynchronizerInstance(\n            this.injector,\n            this.synchronizers ?? {},\n            propertyName\n        ) as Synchronizer<T, PropT, never, RequestParamsT>;\n    }\n}\n"]}

package/esm2022/sync-store.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from "@angular/core";
+import { Store } from "@ngxs/store";
+import { SyncClass } from "./decorators/sync-class";
+import { StateSelector } from "./state-selector";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngxs/store";
+class SyncStore extends Store {
+    injector;
+    _selectorMap;
+    constructor(injector, store) {
+        const internalStore = store;
+        super(internalStore._stateStream, internalStore._internalStateOperations, internalStore._config, internalStore._internalExecutionStrategy, internalStore._stateFactory, undefined);
+        this.injector = injector;
+        this._selectorMap = new Map();
+    }
+    state(syncState) {
+        // If the selector hasn't been created for this state class yet, create it
+        if (!this._selectorMap.has(syncState)) {
+            const statePath = [...SyncClass.resolveParents(syncState).reverse(), syncState];
+            const state$ = this.select(state => statePath.reduce((parentState, childState) => {
+                return parentState[SyncClass.getStoreOptions(childState).name];
+            }, state));
+            // Record each state selector to keep pending requests in sync between state() calls
+            this._selectorMap.set(syncState, new StateSelector(this, syncState, state$));
+        }
+        return this._selectorMap.get(syncState);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: SyncStore, deps: [{ token: i0.Injector }, { token: i1.Store }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: SyncStore });
+}
+export { SyncStore };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: SyncStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.Store }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/synchronizer/state-synchronizer.mjs

@@ -0,0 +1,38 @@
+import { forkJoin, of } from "rxjs";
+import { map, switchMap, take } from "rxjs/operators";
+import { SyncStore } from "../sync-store";
+import { SynchronizerDictionary } from "./synchronizer-dictionary";
+export class StateSynchronizer {
+    injector;
+    propertyState;
+    constructor(injector, propertyState) {
+        this.injector = injector;
+        this.propertyState = propertyState;
+    }
+    read(_requiredDetails, _options) {
+        const syncStore = this.injector.get(SyncStore);
+        const stateSelector = syncStore.state(this.propertyState);
+        // Sync each property in the sub-store that has a synchronizer
+        return this.readSubset(SynchronizerDictionary.keys(stateSelector.synchronizers ?? {}));
+    }
+    readSubset(properties) {
+        const syncStore = this.injector.get(SyncStore);
+        const stateSelector = syncStore.state(this.propertyState);
+        // Sync each property in the sub-store that has a synchronizer and combine with the current store's data
+        return this.readProperties(stateSelector, properties).pipe(map(results => Object.assign({}, ...results)), switchMap(newProperties => stateSelector.properties().pipe(take(1), map(originalProperties => ({
+            ...originalProperties,
+            ...newProperties
+        })))));
+    }
+    readProperties(stateSelector, keys) {
+        // Sync each property in the dictionary
+        return keys.length > 0
+            ? forkJoin(keys.map((propKey) => this.readProperty(stateSelector, propKey)))
+            : of([]);
+    }
+    readProperty(stateSelector, propKey) {
+        // Use `syncProperty` to invoke the synchronizer for this property
+        return stateSelector.syncProperty(propKey).pipe(map(result => ({ [propKey]: result })));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/synchronizer/synchronizer-dictionary.mjs

@@ -0,0 +1,26 @@
+export var SynchronizerDictionary;
+(function (SynchronizerDictionary) {
+    function keys(dict) {
+        return isCollectionSynchronizer(dict) ? [] : Object.keys(dict || {});
+    }
+    SynchronizerDictionary.keys = keys;
+    function isCollectionSynchronizer(dict) {
+        return typeof dict?.prototype?.read === "function";
+    }
+    SynchronizerDictionary.isCollectionSynchronizer = isCollectionSynchronizer;
+    function resolveSynchronizer(dict, propKey) {
+        return isCollectionSynchronizer(dict) ? dict : dict[propKey];
+    }
+    SynchronizerDictionary.resolveSynchronizer = resolveSynchronizer;
+    function resolveSynchronizerInstance(injector, dict, propKey) {
+        const synchronizerDef = resolveSynchronizer(dict, propKey);
+        if (!!synchronizerDef) {
+            return injector.get(synchronizerDef);
+        }
+        else {
+            throw new Error(`A Synchronizer has not been defined for property '${String(propKey)}.`);
+        }
+    }
+    SynchronizerDictionary.resolveSynchronizerInstance = resolveSynchronizerInstance;
+})(SynchronizerDictionary || (SynchronizerDictionary = {}));
+//# sourceMappingURL=data:application/json;base64,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