@casual-simulation/aux-common 3.3.12 → 3.3.14

package/documents/YjsSharedDocument.d.ts

@@ -0,0 +1,152 @@
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { AbstractType as YType, Map as YMap, Array as YArray, Text as YText, RelativePosition, Doc } from 'yjs';
+import { SharedTypeChanges, SharedMap, SharedArray, SharedText, SharedArrayDelta, SharedTextDelta, SharedDocument, SharedType, SharedMapChanges, SharedArrayChanges, SharedTextChanges } from './SharedDocument';
+import { InstUpdate } from '../bots';
+import { CurrentVersion, Action, StatusUpdate } from '../common';
+import { ClientError, InstRecordsClient } from '../websockets';
+import { YjsIndexedDBPersistence } from '../yjs/YjsIndexedDBPersistence';
+import { SharedDocumentConfig } from './SharedDocumentConfig';
+export declare const APPLY_UPDATES_TO_INST_TRANSACTION_ORIGIN = "__apply_updates_to_inst";
+/**
+ * Creates a new YJS shared document.
+ * @param config The config for the document.
+ */
+export declare function createYjsSharedDocument(config: SharedDocumentConfig): YjsSharedDocument;
+/**
+ * Defines a shared document that is backed by a YJS document.
+ */
+export declare class YjsSharedDocument implements SharedDocument {
+    protected _onVersionUpdated: BehaviorSubject<CurrentVersion>;
+    protected _onUpdates: Subject<string[]>;
+    protected _onError: Subject<any>;
+    protected _onEvents: Subject<Action[]>;
+    protected _onStatusUpdated: Subject<StatusUpdate>;
+    protected _onClientError: Subject<ClientError>;
+    protected _sub: Subscription;
+    protected _localId: number;
+    protected _remoteId: number;
+    protected _doc: Doc;
+    protected _client: InstRecordsClient;
+    protected _currentVersion: CurrentVersion;
+    protected _isLocalTransaction: boolean;
+    protected _isRemoteUpdate: boolean;
+    protected _recordName: string | null;
+    protected _inst: string;
+    protected _branch: string;
+    protected _indexeddb: YjsIndexedDBPersistence;
+    protected _persistence: SharedDocumentConfig['localPersistence'];
+    private _maps;
+    private _arrays;
+    private _texts;
+    get recordName(): string;
+    get address(): string;
+    get branch(): string;
+    get clientId(): number;
+    get closed(): boolean;
+    get onVersionUpdated(): Observable<CurrentVersion>;
+    get onError(): Observable<any>;
+    get onEvents(): Observable<Action[]>;
+    get onClientError(): Observable<ClientError>;
+    get onStatusUpdated(): Observable<StatusUpdate>;
+    get site(): string;
+    get onUpdates(): Observable<string[]>;
+    get doc(): Doc;
+    protected get _remoteSite(): string;
+    protected get _currentSite(): string;
+    unsubscribe(): void;
+    constructor(config: SharedDocumentConfig);
+    getMap<T = any>(name: string): SharedMap<T>;
+    getArray<T = any>(name: string): SharedArray<T>;
+    getText(name: string): SharedText;
+    createMap<T = any>(): SharedMap<T>;
+    createArray<T = any>(): SharedArray<T>;
+    init(): Promise<void>;
+    connect(): void;
+    transact(callback: () => void): void;
+    getStateUpdate(): InstUpdate;
+    applyStateUpdates(updates: InstUpdate[]): void;
+    /**
+     * Applies the given updates to the YJS document.
+     * @param updates The updates to apply.
+     * @param transactionOrigin The origin of the transaction.
+     */
+    protected _applyUpdates(updates: string[], transactionOrigin?: string): void;
+}
+export declare class YjsSharedType<TType extends YType<any>, TChanges extends SharedTypeChanges> {
+    private _type;
+    private _changes;
+    private _deepChanges;
+    get type(): TType;
+    get doc(): SharedDocument;
+    get parent(): SharedType;
+    get changes(): Observable<TChanges>;
+    get deepChanges(): Observable<SharedTypeChanges[]>;
+    constructor(type: TType);
+}
+export declare class YjsSharedMap<T> extends YjsSharedType<YMap<T>, SharedMapChanges<T>> implements SharedMap<T> {
+    constructor(map: YMap<T>);
+    constructor(map: Map<string, T>);
+    get size(): number;
+    set(key: string, value: T): void;
+    get(key: string): T;
+    delete(key: string): void;
+    has(key: string): boolean;
+    clear(): void;
+    clone(): SharedMap<T>;
+    toJSON(): {
+        [key: string]: T;
+    };
+    forEach(callback: (value: T, key: string, map: SharedMap<T>) => void): void;
+    entries(): IterableIterator<[string, T]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<[string, T]>;
+}
+export declare class YjsSharedArray<T> extends YjsSharedType<YArray<T>, SharedArrayChanges<T>> implements SharedArray<T> {
+    get length(): number;
+    get size(): number;
+    constructor(arr: YArray<T>);
+    constructor(arr: Array<T>);
+    insert(index: number, items: T[]): void;
+    delete(index: number, count: number): void;
+    applyDelta(delta: SharedArrayDelta<T>): void;
+    push(...items: T[]): void;
+    pop(): T | undefined;
+    unshift(...items: T[]): void;
+    shift(): T | undefined;
+    get(index: number): T;
+    slice(start?: number, end?: number): T[];
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    toArray(): T[];
+    toJSON(): T[];
+    forEach(callback: (value: T, index: number, array: SharedArray<T>) => void): void;
+    map(callback: (value: T, index: number, array: SharedArray<T>) => T): T[];
+    filter(predicate: (value: T, index: number, array: SharedArray<T>) => boolean): T[];
+    clone(): SharedArray<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+    private _mapItems;
+}
+export declare class YjsSharedText implements SharedText {
+    private _text;
+    private _changes;
+    private _deepChanges;
+    get doc(): SharedDocument;
+    get parent(): SharedType;
+    get length(): number;
+    get size(): number;
+    get changes(): Observable<SharedTextChanges>;
+    get deepChanges(): Observable<SharedTextChanges[]>;
+    constructor(text: YText);
+    constructor(text: string);
+    insert(index: number, text: string, attribtues?: Record<string, any>): void;
+    delete(index: number, count: number): void;
+    applyDelta(delta: SharedTextDelta): void;
+    toDelta(): SharedTextDelta;
+    encodeRelativePosition(index: number, assoc?: number): RelativePosition;
+    decodeRelativePosition(position: RelativePosition): number;
+    slice(start?: number, end?: number): string;
+    toString(): string;
+    toJSON(): string;
+    clone(): SharedText;
+}
+//# sourceMappingURL=YjsSharedDocument.d.ts.map