@syncable/core/bld/library/syncable/syncable-container.d.ts

Syncable.

import { KeyOfValueWithType } from 'tslang';
import { ISyncable, SyncableRef } from './syncable';
import { ISyncableAdapter } from './syncable-adapter';
import { ISyncableObject } from './syncable-object';
declare type RefDictToSyncableDict<TRefDict extends object> = {
    [TName in keyof TRefDict]: TRefDict[TName] extends ISyncableObject ? TRefDict[TName]['syncable'] : TRefDict[TName] extends ISyncableObject[] ? TRefDict[TName][number]['syncable'] : never;
};
export declare type RefDictToSyncableObjectDict<T extends object> = T extends object ? {
    [TName in KeyOfValueWithType<Required<T>, SyncableRef>]: NonNullable<T[TName]> extends SyncableRef<infer TSyncableObject> ? TSyncableObject | (undefined extends T[TName] ? undefined : never) : never;
} & {
    [TName in KeyOfValueWithType<Required<T>, SyncableRef[]>]: NonNullable<T[TName]> extends SyncableRef<infer TSyncableObject>[] ? TSyncableObject[] | (undefined extends T[TName] ? undefined : never) : never;
} : never;
export declare class SyncableContainer<TSyncableObject extends ISyncableObject = ISyncableObject> {
    readonly adapter: ISyncableAdapter;
    private typeToIdToSyncableMapMap;
    private typeToIdToSyncableObjectMapMap;
    constructor(adapter: ISyncableAdapter);
    buildSyncableDict<TRefDict extends object>(refDict: TRefDict): RefDictToSyncableDict<TRefDict>;
    buildSyncableObjectDict<TRefDict extends object>(refDict: TRefDict): RefDictToSyncableObjectDict<TRefDict>;
    getSyncables<TType extends TSyncableObject['syncable']['_type']>(type?: TType): Extract<TSyncableObject['syncable'], {
        _type: TType;
    }>[];
    getSyncable<TRef extends TSyncableObject['ref']>({ type, id, }: TRef): Extract<TSyncableObject, {
        ref: TRef;
    }>['syncable'] | undefined;
    requireSyncable<TRef extends TSyncableObject['ref']>(ref: TRef): Extract<TSyncableObject, {
        ref: TRef;
    }>['syncable'];
    existsSyncable({ type, id }: SyncableRef<TSyncableObject>): boolean;
    getSyncableObjects<TType extends TSyncableObject['syncable']['_type']>(type?: TType): Extract<TSyncableObject, {
        syncable: {
            _type: TType;
        };
    }>[];
    getSyncableObject<TRef extends TSyncableObject['ref']>(ref: TRef): Extract<TSyncableObject, {
        ref: TRef;
    }> | undefined;
    requireSyncableObject<TRef extends TSyncableObject['ref']>(ref: TRef): Extract<TSyncableObject, {
        ref: TRef;
    }>;
    /**
     * Add a syncable, please notice that it won't change the reference of the
     * originally stored syncable. Instead, differences will be applied to it.
     */
    addSyncable(snapshot: ISyncable, clock?: number): void;
    updateMatchingSyncable(snapshot: ISyncable, clock?: number): void;
    removeSyncable({ type, id }: SyncableRef): void;
    clear(): void;
}
export {};