@pluv/crdt-yjs 0.14.1 → 0.16.0

package/src/array/array.ts

@@ -0,0 +1,7 @@
+import { CrdtYjsArray } from "./CrdtYjsArray";
+
+export const array = <T extends unknown>(
+    value: T[] | readonly T[] = [],
+): CrdtYjsArray<T> => {
+    return new CrdtYjsArray<T>(value);
+};

package/src/array/index.ts

@@ -0,0 +1,2 @@
+export { array } from "./array";
+export { CrdtYjsArray } from "./CrdtYjsArray";

package/src/doc/CrdtYjsDoc.ts

@@ -0,0 +1,274 @@
+import type {
+    AbstractCrdtType,
+    DocApplyEncodedStateParams,
+    DocSubscribeCallbackParams,
+    InferCrdtStorageJson,
+} from "@pluv/crdt";
+import { AbstractCrdtDoc } from "@pluv/crdt";
+import { fromUint8Array, toUint8Array } from "js-base64";
+import {
+    UndoManager,
+    AbstractType as YAbstractType,
+    Array as YArray,
+    Doc as YDoc,
+    Map as YMap,
+    Text as YText,
+    XmlElement as YXmlElement,
+    XmlFragment as YXmlFragment,
+    XmlText as YXmlText,
+    applyUpdate,
+    encodeStateAsUpdate,
+} from "yjs";
+import { CrdtYjsArray } from "../array/CrdtYjsArray";
+import { CrdtYjsMap } from "../map/CrdtYjsMap";
+import { CrdtYjsObject } from "../object/CrdtYjsObject";
+import { CrdtYjsText } from "../text/CrdtYjsText";
+import { CrdtYjsXmlElement } from "../xmlElement/CrdtYjsXmlElement";
+import { CrdtYjsXmlFragment } from "../xmlFragment/CrdtYjsXmlFragment";
+import { CrdtYjsXmlText } from "../xmlText/CrdtYjsXmlText";
+
+export class CrdtYjsDoc<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> extends AbstractCrdtDoc<TStorage> {
+    public value: YDoc = new YDoc();
+
+    private _storage: TStorage;
+    private _undoManager: UndoManager | null = null;
+
+    constructor(value: TStorage = {} as TStorage) {
+        super();
+
+        this._storage = Object.entries(value).reduce((acc, [key, node]) => {
+            if (node instanceof CrdtYjsArray) {
+                const yArray = this.value.get(key, YArray) as YArray<any>;
+                yArray.insert(0, node.initialValue.slice(0));
+
+                node.value = yArray;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsMap || node instanceof CrdtYjsObject) {
+                const yMap = this.value.get(key, YMap) as YMap<any>;
+                node.initialValue.forEach(([k, v]) => {
+                    yMap.set(k.toString(), v);
+                });
+
+                node.value = yMap;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsObject) {
+                const yMap = this.value.get(key, YMap) as YMap<any>;
+                node.initialValue.forEach(([k, v]) => {
+                    yMap.set(k.toString(), v);
+                });
+
+                node.value = yMap;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsText) {
+                const yText = this.value.get(key, YText) as YText;
+                yText.insert(0, node.initialValue);
+
+                node.value = yText;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsXmlElement) {
+                const yXmlElement = this.value.get(
+                    key,
+                    YXmlElement,
+                ) as YXmlElement;
+                yXmlElement.insert(0, node.initialValue.slice(0));
+
+                node.value = yXmlElement;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsXmlFragment) {
+                const yXmlFragment = this.value.get(
+                    key,
+                    YXmlFragment,
+                ) as YXmlFragment;
+                yXmlFragment.insert(0, node.initialValue.slice(0));
+
+                node.value = yXmlFragment;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtYjsXmlText) {
+                const yXmlText = this.value.get(key, YXmlText) as YXmlText;
+                yXmlText.insert(0, node.initialValue);
+
+                node.value = yXmlText;
+
+                return { ...acc, [key]: node };
+            }
+
+            return acc;
+        }, {} as TStorage);
+    }
+
+    public applyEncodedState(params: DocApplyEncodedStateParams): this {
+        const { origin, update } = params;
+
+        if (update === null || typeof update === "undefined") return this;
+
+        const uint8Update =
+            typeof update === "string" ? toUint8Array(update) : update;
+
+        applyUpdate(this.value, uint8Update, origin);
+
+        return this;
+    }
+
+    public batchApplyEncodedState(
+        updates: readonly (
+            | DocApplyEncodedStateParams
+            | string
+            | null
+            | undefined
+        )[],
+    ): this {
+        const params = updates.reduce<DocApplyEncodedStateParams[]>(
+            (acc, update) => {
+                if (!update) return acc;
+
+                if (typeof update === "string") {
+                    acc.push({ update });
+
+                    return acc;
+                }
+
+                if (!!update && typeof update === "object") {
+                    acc.push(update);
+
+                    return acc;
+                }
+
+                return acc;
+            },
+            [],
+        );
+
+        return params.reduce(
+            (doc, update) => doc.applyEncodedState(update),
+            this,
+        );
+    }
+
+    public canRedo(): boolean {
+        return !!this._undoManager?.canRedo();
+    }
+
+    public canUndo(): boolean {
+        return !!this._undoManager?.canUndo();
+    }
+
+    public destroy(): void {
+        this._undoManager?.destroy();
+        this.value.destroy();
+    }
+
+    public get(key?: undefined): TStorage;
+    public get<TKey extends keyof TStorage>(key: TKey): TStorage[TKey];
+    public get<TKey extends keyof TStorage>(
+        key?: TKey,
+    ): TStorage | TStorage[TKey] {
+        if (typeof key === "undefined") return this._storage;
+
+        return this._storage[key as TKey];
+    }
+
+    public getEncodedState(): string {
+        return fromUint8Array(encodeStateAsUpdate(this.value));
+    }
+
+    public isEmpty(): boolean {
+        return !this.value.share.size;
+    }
+
+    public redo(): this {
+        this._undoManager?.redo();
+
+        return this;
+    }
+
+    public subscribe(
+        listener: (params: DocSubscribeCallbackParams<TStorage>) => void,
+    ): () => void {
+        const fn = (update: Uint8Array, origin: any, doc: YDoc) => {
+            listener({
+                doc: this,
+                local: origin === null || typeof origin === "undefined",
+                origin: origin ? String(origin) : null,
+                update: fromUint8Array(update),
+            });
+        };
+
+        this.value.on("update", fn);
+
+        return () => {
+            this.value.off("update", fn);
+        };
+    }
+
+    public track(): this {
+        if (this._undoManager) this._undoManager.destroy();
+
+        const sharedTypes = Object.values(this._storage).reduce<
+            YAbstractType<any>[]
+        >((acc, type) => {
+            if (
+                type instanceof CrdtYjsArray ||
+                type instanceof CrdtYjsMap ||
+                type instanceof CrdtYjsObject ||
+                type instanceof CrdtYjsText ||
+                type instanceof CrdtYjsXmlElement ||
+                type instanceof CrdtYjsXmlFragment ||
+                type instanceof CrdtYjsXmlText
+            ) {
+                acc.push(type.value);
+            }
+
+            return acc;
+        }, []);
+
+        if (!sharedTypes.length) {
+            this._undoManager?.destroy();
+            this._undoManager = null;
+
+            return this;
+        }
+
+        this._undoManager = new UndoManager(sharedTypes, { captureTimeout: 0 });
+
+        return this;
+    }
+
+    public transact(fn: () => void): this {
+        this.value.transact(fn);
+
+        return this;
+    }
+
+    public toJson(): InferCrdtStorageJson<TStorage> {
+        return Object.entries(this._storage).reduce(
+            (acc, [key, value]) => ({ ...acc, [key]: value.toJson() }),
+            {} as InferCrdtStorageJson<TStorage>,
+        );
+    }
+
+    public undo(): this {
+        this._undoManager?.undo();
+
+        return this;
+    }
+}

package/src/doc/CrdtYjsDocFactory.ts

@@ -0,0 +1,83 @@
+import type { AbstractCrdtType } from "@pluv/crdt";
+import { AbstractCrdtDocFactory } from "@pluv/crdt";
+import { CrdtYjsArray } from "../array";
+import { CrdtYjsMap } from "../map";
+import { CrdtYjsObject } from "../object";
+import { CrdtYjsText } from "../text";
+import { CrdtYjsXmlElement } from "../xmlElement";
+import { CrdtYjsXmlFragment } from "../xmlFragment";
+import { CrdtYjsXmlText } from "../xmlText";
+import { CrdtYjsDoc } from "./CrdtYjsDoc";
+
+export class CrdtYjsDocFactory<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> extends AbstractCrdtDocFactory<TStorage> {
+    private _initialStorage: () => TStorage;
+
+    constructor(initialStorage: () => TStorage = () => ({}) as TStorage) {
+        super();
+
+        this._initialStorage = initialStorage;
+    }
+
+    public getEmpty(): CrdtYjsDoc<TStorage> {
+        return new CrdtYjsDoc<TStorage>();
+    }
+
+    public getFactory(
+        initialStorage?: (() => TStorage) | undefined,
+    ): CrdtYjsDocFactory<TStorage> {
+        return new CrdtYjsDocFactory<TStorage>(
+            initialStorage ?? this._initialStorage,
+        );
+    }
+
+    public getFresh(): CrdtYjsDoc<TStorage> {
+        const storage = this._initialStorage();
+
+        return new CrdtYjsDoc<TStorage>(
+            Object.entries(storage).reduce((acc, [key, node]) => {
+                if (node instanceof CrdtYjsArray) {
+                    return { ...acc, [key]: new CrdtYjsArray([]) };
+                }
+
+                if (node instanceof CrdtYjsMap) {
+                    return { ...acc, [key]: new CrdtYjsMap([]) };
+                }
+
+                if (node instanceof CrdtYjsObject) {
+                    return { ...acc, [key]: new CrdtYjsObject({}) };
+                }
+
+                if (node instanceof CrdtYjsText) {
+                    return { ...acc, [key]: new CrdtYjsText("") };
+                }
+
+                if (node instanceof CrdtYjsXmlElement) {
+                    return {
+                        ...acc,
+                        [key]: new CrdtYjsXmlElement(node.name, []),
+                    };
+                }
+
+                if (node instanceof CrdtYjsXmlFragment) {
+                    return { ...acc, [key]: new CrdtYjsXmlFragment([]) };
+                }
+
+                if (node instanceof CrdtYjsXmlText) {
+                    return { ...acc, [key]: new CrdtYjsXmlText("") };
+                }
+
+                return acc;
+            }, {} as TStorage),
+        );
+    }
+
+    public getInitialized(
+        initialStorage?: () => TStorage,
+    ): CrdtYjsDoc<TStorage> {
+        return new CrdtYjsDoc<TStorage>(
+            initialStorage?.() ?? this._initialStorage(),
+        );
+    }
+}

package/src/doc/doc.ts

@@ -0,0 +1,10 @@
+import type { AbstractCrdtType } from "@pluv/crdt";
+import { CrdtYjsDocFactory } from "./CrdtYjsDocFactory";
+
+export const doc = <
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+>(
+    value: () => TStorage = () => ({}) as TStorage,
+): CrdtYjsDocFactory<TStorage> => {
+    return new CrdtYjsDocFactory<TStorage>(value);
+};

package/src/doc/index.ts

@@ -0,0 +1,3 @@
+export { CrdtYjsDoc } from "./CrdtYjsDoc";
+export { CrdtYjsDocFactory } from "./CrdtYjsDocFactory";
+export { doc } from "./doc";

package/src/index.ts

@@ -1,20 +1 @@
-export type { AbstractType, Array, Map, Text } from "yjs";
-export { array } from "./array";
-export type { TrackOriginOptions } from "./doc";
-export { YjsDoc, doc } from "./doc";
-export { map } from "./map";
-export { object } from "./object";
-export type { YObject, YObjectValue } from "./object";
-export { text } from "./text";
-export type {
-    InferYjsDocJson,
-    InferYjsDocSharedType,
-    InferYjsDocSharedTypeJson,
-    InferYjsDocSharedTypes,
-    InferYjsSharedTypeJson,
-} from "./types";
-export { xmlElement } from "./xmlElement";
-export type { XmlElementParams } from "./xmlElement";
-export { xmlFragment } from "./xmlFragment";
-export type { XmlFragmentParams } from "./xmlFragment";
-export { xmlText } from "./xmlText";
+export * as yjs from "./yjs";

package/src/map/CrdtYjsMap.ts

@@ -0,0 +1,43 @@
+import type { InferCrdtStorageJson } from "@pluv/crdt";
+import { AbstractCrdtType } from "@pluv/crdt";
+import { Map as YMap } from "yjs";
+import { toYjsValue } from "../shared";
+import type { InferYjsJson, InferYjsType } from "../types";
+
+export class CrdtYjsMap<T extends unknown> extends AbstractCrdtType<
+    YMap<InferYjsType<T>>,
+    Record<string, InferYjsJson<T>>
+> {
+    public initialValue: readonly (readonly [
+        key: string,
+        value: InferYjsType<T>,
+    ])[];
+    public value: YMap<InferYjsType<T>>;
+
+    constructor(value: readonly (readonly [key: string, value: T])[] = []) {
+        super();
+
+        this.initialValue = value.map(([k, v]) => [k, toYjsValue(v)]);
+        this.value = new YMap(this.initialValue);
+    }
+
+    public get size(): number {
+        return this.value.size;
+    }
+
+    public delete(prop: string): this {
+        this.value.delete(prop);
+
+        return this;
+    }
+
+    public set(prop: string, value: T): this {
+        this.value.set(prop, toYjsValue(value));
+
+        return this;
+    }
+
+    public toJson(): InferCrdtStorageJson<Record<string, InferYjsJson<T>>> {
+        return this.value.toJSON();
+    }
+}

package/src/map/index.ts

@@ -0,0 +1,2 @@
+export { CrdtYjsMap } from "./CrdtYjsMap";
+export { map } from "./map";

package/src/{map.ts → map/map.ts}

@@ -1,7 +1,7 @@
-import { Map as YMap } from "yjs";
+import { CrdtYjsMap } from "./CrdtYjsMap";
 
 export const map = <T extends unknown>(
     value: readonly (readonly [key: string, value: T])[] = [],
-): YMap<T> => {
-    return new YMap(value);
+): CrdtYjsMap<T> => {
+    return new CrdtYjsMap<T>(value);
 };

package/src/object/CrdtYjsObject.ts

@@ -0,0 +1,32 @@
+import type { InferCrdtStorageJson } from "@pluv/crdt";
+import { AbstractCrdtType } from "@pluv/crdt";
+import { Map as YMap } from "yjs";
+import { toYjsValue } from "../shared";
+import type { InferYjsJson, InferYjsType } from "../types";
+
+export class CrdtYjsObject<
+    T extends Record<string, any>,
+> extends AbstractCrdtType<YMap<InferYjsType<T[keyof T]>>, InferYjsJson<T>> {
+    public initialValue: readonly (readonly [key: string, value: T[keyof T]])[];
+    public value: YMap<InferYjsType<T[keyof T]>>;
+
+    constructor(value: T = {} as T) {
+        super();
+
+        this.initialValue = Object.entries(value).map(([k, v]) => [
+            k,
+            toYjsValue(v),
+        ]);
+        this.value = new YMap(this.initialValue);
+    }
+
+    public set<TProp extends keyof T>(prop: TProp, value: T[TProp]): this {
+        this.value.set(prop.toString(), toYjsValue(value));
+
+        return this;
+    }
+
+    public toJson(): InferCrdtStorageJson<InferYjsJson<T>> {
+        return this.value.toJSON() as InferCrdtStorageJson<InferYjsJson<T>>;
+    }
+}

package/src/object/index.ts

@@ -0,0 +1,2 @@
+export { CrdtYjsObject } from "./CrdtYjsObject";
+export { object } from "./object";

package/src/object/object.ts

@@ -0,0 +1,7 @@
+import { CrdtYjsObject } from "./CrdtYjsObject";
+
+export const object = <T extends Record<string, any>>(
+    value: T,
+): CrdtYjsObject<T> => {
+    return new CrdtYjsObject(value);
+};

package/src/shared/index.ts

@@ -0,0 +1,2 @@
+export { isWrapper } from "./isWrapper";
+export { toYjsValue } from "./toYjsValue";

package/src/shared/isWrapper.ts

@@ -0,0 +1,25 @@
+import { CrdtYjsArray } from "../array/CrdtYjsArray";
+import { CrdtYjsMap } from "../map/CrdtYjsMap";
+import { CrdtYjsObject } from "../object/CrdtYjsObject";
+import { CrdtYjsText } from "../text/CrdtYjsText";
+import { CrdtYjsXmlElement } from "../xmlElement";
+import { CrdtYjsXmlFragment } from "../xmlFragment";
+import { CrdtYjsXmlText } from "../xmlText";
+
+export const isWrapper = (
+    item: any,
+): item is
+    | CrdtYjsArray<any>
+    | CrdtYjsMap<any>
+    | CrdtYjsObject<any>
+    | CrdtYjsText => {
+    return (
+        item instanceof CrdtYjsArray ||
+        item instanceof CrdtYjsMap ||
+        item instanceof CrdtYjsObject ||
+        item instanceof CrdtYjsText ||
+        item instanceof CrdtYjsXmlElement ||
+        item instanceof CrdtYjsXmlFragment ||
+        item instanceof CrdtYjsXmlText
+    );
+};

package/src/shared/toYjsValue.ts

@@ -0,0 +1,5 @@
+import { isWrapper } from "./isWrapper";
+
+export const toYjsValue = (item: any): any => {
+    return isWrapper(item) ? item.value : item;
+};

package/src/text/CrdtYjsText.ts

@@ -0,0 +1,34 @@
+import { AbstractCrdtType } from "@pluv/crdt";
+import { Text as YText } from "yjs";
+
+export class CrdtYjsText extends AbstractCrdtType<YText, string> {
+    public readonly initialValue: string;
+    public value: YText;
+
+    constructor(value: string = "") {
+        super();
+
+        this.initialValue = value;
+        this.value = new YText(value);
+    }
+
+    public get length(): number {
+        return this.value.length;
+    }
+
+    public delete(index: number, length: number = 1): this {
+        this.value.delete(index, length);
+
+        return this;
+    }
+
+    public insert(index: number, text: string): this {
+        this.value.insert(index, text);
+
+        return this;
+    }
+
+    public toJson(): string {
+        return this.value.toJSON();
+    }
+}

package/src/text/index.ts

@@ -0,0 +1,2 @@
+export { CrdtYjsText } from "./CrdtYjsText";
+export { text } from "./text";

package/src/text/text.ts

@@ -0,0 +1,5 @@
+import { CrdtYjsText } from "./CrdtYjsText";
+
+export const text = (value: string = ""): CrdtYjsText => {
+    return new CrdtYjsText(value);
+};