ngxs-synchronizers 3.0.0 → 4.0.1

package/sync-store.d.ts

@@ -1,13 +0,0 @@
-import { Injector } 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";
-export declare class SyncStore extends Store {
-    readonly injector: Injector;
-    private readonly _selectorMap;
-    constructor(injector: Injector, store: Store);
-    state<T>(syncState: SyncClass<T>): StateSelector<T>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<SyncStore, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<SyncStore>;
-}

package/synchronizer/collection-synchronizer.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from "rxjs";
-import { Synchronizer } from "./synchronizer";
-export interface CollectionSynchronizer<T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, keyof T, ReadParamsT, WriteParamsT> {
-    read(requiredDetails: Partial<T>, options: CollectionSynchronizer.ReadOptions<T, ReadParamsT>): Observable<T[keyof T]>;
-    write?(value: T[keyof T], options: CollectionSynchronizer.WriteOptions<T, WriteParamsT>): Observable<any>;
-}
-export declare namespace CollectionSynchronizer {
-    type ReadOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
-    type WriteOptions<T, ParamsT = never> = Synchronizer.BaseOptions<T, keyof T, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
-}

package/synchronizer/property-synchronizer.d.ts

@@ -1,10 +0,0 @@
-import { Observable } from "rxjs";
-import { Synchronizer } from "./synchronizer";
-export interface PropertySynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> extends Synchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
-    read(requiredDetails: Partial<T>, options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
-    write?(value: T[PropKey], options: PropertySynchronizer.WriteOptions<T, PropKey, WriteParamsT>): Observable<any>;
-}
-export declare namespace PropertySynchronizer {
-    type ReadOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.ReadOptions<ParamsT>;
-    type WriteOptions<T, PropKey extends keyof T = keyof T, ParamsT = never> = Synchronizer.BaseOptions<T, PropKey, ParamsT> & Synchronizer.WriteOptions<ParamsT>;
-}

package/synchronizer/state-synchronizer.d.ts

@@ -1,13 +0,0 @@
-import { Injector } from "@angular/core";
-import { Observable } from "rxjs";
-import { SyncClass } from "../decorators/sync-class";
-import { PropertySynchronizer } from "./property-synchronizer";
-export declare abstract class StateSynchronizer<T, PropKey extends keyof T, ReadParamsT = never, WriteParamsT = never> implements PropertySynchronizer<T, PropKey, ReadParamsT, WriteParamsT> {
-    private readonly injector;
-    private readonly propertyState;
-    constructor(injector: Injector, propertyState: SyncClass<T[PropKey]>);
-    read(_requiredDetails: Partial<T>, _options: PropertySynchronizer.ReadOptions<T, PropKey, ReadParamsT>): Observable<T[PropKey]>;
-    protected readSubset(properties: Array<keyof T[PropKey]>): Observable<T[PropKey]>;
-    private readProperties;
-    private readProperty;
-}

package/synchronizer/synchronizer-dictionary.d.ts

@@ -1,13 +0,0 @@
-import { Injector, Type } from "@angular/core";
-import { CollectionSynchronizer } from "./collection-synchronizer";
-import { PropertySynchronizer } from "./property-synchronizer";
-import { Synchronizer } from "./synchronizer";
-export type SynchronizerDictionary<T> = {
-    [P in keyof T]?: Type<PropertySynchronizer<T, P>>;
-} | Type<CollectionSynchronizer<T>>;
-export declare namespace SynchronizerDictionary {
-    function keys<T>(dict: SynchronizerDictionary<T>): Array<keyof T>;
-    function isCollectionSynchronizer<T>(dict: SynchronizerDictionary<T>): dict is Type<CollectionSynchronizer<T>>;
-    function resolveSynchronizer<T>(dict: SynchronizerDictionary<T>, propKey: keyof T): Type<Synchronizer<T, keyof T, unknown, unknown>> | undefined;
-    function resolveSynchronizerInstance<T>(injector: Injector, dict: SynchronizerDictionary<T>, propKey: keyof T): Synchronizer<T, keyof T, unknown, unknown>;
-}

package/synchronizer/synchronizer.d.ts

@@ -1,20 +0,0 @@
-import { Observable } from "rxjs";
-export interface Synchronizer<T, PropKey extends keyof T, ReadParamsT, WriteParamsT> {
-    requiredProperties?: Array<keyof T>;
-    proxy?: boolean;
-    read(requiredDetails: Partial<T>, options: Synchronizer.BaseOptions<T, PropKey, ReadParamsT> & Synchronizer.ReadOptions<ReadParamsT>): Observable<T[PropKey]>;
-    write?(value: T[PropKey], options: Synchronizer.BaseOptions<T, PropKey, WriteParamsT> & Synchronizer.WriteOptions<WriteParamsT>): Observable<any>;
-}
-export declare namespace Synchronizer {
-    interface BaseOptions<T, PropKey extends keyof T, ParamsT> {
-        propertyName: PropKey;
-        requestParams?: ParamsT;
-    }
-    interface ReadOptions<ParamsT> {
-        clearStore?: boolean;
-        requestParams?: ParamsT;
-    }
-    interface WriteOptions<ParamsT> {
-        requestParams?: ParamsT;
-    }
-}