@casual-simulation/aux-common/documents/YjsSharedDocument.d.ts

Common library for AUX projects

import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
import type { RelativePosition } from 'yjs';
import { AbstractType as YType, Map as YMap, Array as YArray, Text as YText, Doc } from 'yjs';
import type { SharedTypeChanges, SharedMap, SharedArray, SharedText, SharedTextDelta, SharedDocument, SharedType, SharedMapChanges, SharedArrayChanges, SharedTextChanges, SharedArrayOp } from './SharedDocument';
import type { InstUpdate } from '../bots';
import type { CurrentVersion, Action, StatusUpdate } from '../common';
import type { ClientError, InstRecordsClient } from '../websockets';
import { YjsIndexedDBPersistence } from '../yjs/YjsIndexedDBPersistence';
import type { 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;
    applyUpdates(updates: string[]): 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: SharedArrayOp<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