@pluv/crdt-loro 0.16.0

package/src/array/CrdtLoroArray.ts

@@ -0,0 +1,102 @@
+import { AbstractCrdtType, type InferCrdtStorageJson } from "@pluv/crdt";
+import { LoroList } from "loro-crdt";
+import type { CrdtLoroDoc } from "../doc/CrdtLoroDoc";
+import { cloneType, getLoroContainerType, isWrapper } from "../shared";
+import type { InferLoroJson } from "../types";
+
+export class CrdtLoroArray<T extends unknown> extends AbstractCrdtType<
+    LoroList<T[]>,
+    InferLoroJson<T>[]
+> {
+    public readonly initialValue: T[] | readonly T[];
+
+    private _doc: CrdtLoroDoc<any> | null = null;
+    private _initialized: boolean = false;
+    private _value: LoroList<T[]> = new LoroList();
+
+    constructor(value: T[] | readonly T[] = []) {
+        super();
+
+        this.initialValue = value.slice();
+    }
+
+    public set doc(doc: CrdtLoroDoc<any>) {
+        if (this._doc) throw new Error("Cannot overwrite array doc");
+
+        this._doc = doc;
+    }
+
+    public get length(): number {
+        return this.value.length;
+    }
+
+    public get value(): LoroList<T[]> {
+        return this._value;
+    }
+
+    public set value(value: LoroList<T[]>) {
+        if (this._initialized) throw new Error("Cannot re-assign array");
+
+        this._initialized = true;
+        this._value = value;
+
+        cloneType({ source: this, target: this.value });
+    }
+
+    public delete(index: number, length: number = 1): this {
+        this._guardInitialized();
+
+        this.value.delete(index, length);
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public insert(index: number, ...items: T[]): this {
+        this._guardInitialized();
+
+        items.forEach((item, i) => {
+            if (!(item instanceof AbstractCrdtType)) {
+                this.value.insert(index + i, item);
+                this._doc?.value.commit();
+
+                return this;
+            }
+
+            if (!isWrapper(item)) {
+                throw new Error("This type is not yet supported");
+            }
+
+            const containerType = getLoroContainerType(item);
+            const container = this.value.insertContainer(
+                index + i,
+                containerType,
+            );
+
+            cloneType({ source: item, target: container as any });
+            if (this._doc) item.doc = this._doc;
+
+            return this;
+        });
+
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public push(...items: T[]): this {
+        return this.insert(this.length, ...items);
+    }
+
+    public unshift(...items: T[]): this {
+        return this.insert(0, ...items);
+    }
+
+    public toJson(): InferCrdtStorageJson<InferLoroJson<T>>[] {
+        return this.value.toJson();
+    }
+
+    private _guardInitialized(): void {
+        if (!this._initialized) throw new Error("Array is not yet initialized");
+    }
+}

package/src/array/array.ts

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

package/src/array/index.ts

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

package/src/doc/CrdtLoroDoc.ts

@@ -0,0 +1,239 @@
+import type {
+    AbstractCrdtType,
+    DocApplyEncodedStateParams,
+    DocSubscribeCallbackParams,
+    InferCrdtStorageJson,
+} from "@pluv/crdt";
+import { AbstractCrdtDoc } from "@pluv/crdt";
+import { fromUint8Array, toUint8Array } from "js-base64";
+import type { Container, LoroEventBatch } from "loro-crdt";
+import { Loro } from "loro-crdt";
+import { CrdtLoroArray } from "../array/CrdtLoroArray";
+import { CrdtLoroMap } from "../map/CrdtLoroMap";
+import { CrdtLoroObject } from "../object/CrdtLoroObject";
+import { CrdtLoroText } from "../text/CrdtLoroText";
+
+export class CrdtLoroDoc<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> extends AbstractCrdtDoc<TStorage> {
+    public value: Loro = new Loro();
+
+    private _storage: TStorage;
+
+    constructor(value: TStorage = {} as TStorage) {
+        super();
+
+        this._storage = Object.entries(value).reduce((acc, [key, node]) => {
+            if (node instanceof CrdtLoroArray) {
+                const loroList = this.value.getList(key);
+
+                node.value = loroList;
+                node.doc = this;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtLoroMap || node instanceof CrdtLoroObject) {
+                const loroMap = this.value.getMap(key);
+
+                node.value = loroMap;
+                node.doc = this;
+
+                return { ...acc, [key]: node };
+            }
+
+            if (node instanceof CrdtLoroText) {
+                const loroText = this.value.getText(key);
+
+                node.value = loroText;
+                node.doc = this;
+
+                return { ...acc, [key]: loroText };
+            }
+
+            return acc;
+        }, {} as TStorage);
+    }
+
+    public applyEncodedState(params: DocApplyEncodedStateParams): this {
+        const update =
+            typeof params.update === "string"
+                ? toUint8Array(params.update)
+                : params.update;
+
+        if (!update) return this;
+
+        this.value.import(update);
+
+        return this;
+    }
+
+    public batchApplyEncodedState(
+        updates: readonly (
+            | DocApplyEncodedStateParams
+            | string
+            | null
+            | undefined
+        )[],
+    ): this {
+        const _updates = updates.reduce<Uint8Array[]>((acc, item) => {
+            if (!item) return acc;
+
+            if (typeof item === "string") {
+                acc.push(toUint8Array(item));
+
+                return acc;
+            }
+
+            if (typeof item === "object") {
+                const update =
+                    typeof item.update === "string"
+                        ? toUint8Array(item.update)
+                        : item.update;
+
+                if (!update) return acc;
+
+                acc.push(update);
+
+                return acc;
+            }
+
+            return acc;
+        }, []);
+
+        if (!_updates.length) return this;
+
+        if (_updates.length === 1) {
+            const update = _updates[0] ?? null;
+
+            update && this.value.import(update);
+
+            return this;
+        }
+
+        this.value.importUpdateBatch(_updates);
+
+        return this;
+    }
+
+    /**
+     * TODO
+     * @description This method is not yet supported for loro
+     */
+    public canRedo(): boolean {
+        return false;
+    }
+
+    /**
+     * TODO
+     * @description This method is not yet supported for loro
+     */
+    public canUndo(): boolean {
+        return false;
+    }
+
+    public destroy(): void {
+        return;
+    }
+
+    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(this.value.exportSnapshot());
+    }
+
+    public toJson(): InferCrdtStorageJson<TStorage> {
+        return Object.entries(this._storage).reduce(
+            (acc, [key, value]) => ({ ...acc, [key]: value.toJson() }),
+            {} as InferCrdtStorageJson<TStorage>,
+        );
+    }
+
+    public isEmpty(): boolean {
+        const serialized = this.value.toJson();
+
+        return !serialized || !Object.keys(serialized).length;
+    }
+
+    /**
+     * TODO
+     * @description This method is not yet supported for loro
+     */
+    public redo(): this {
+        throw new Error("This is not yet supported");
+    }
+
+    public subscribe(
+        listener: (params: DocSubscribeCallbackParams<TStorage>) => void,
+    ): () => void {
+        const fn = (event: LoroEventBatch) => {
+            const update = fromUint8Array(this.value.exportFrom());
+
+            listener({
+                doc: this,
+                local: event.local,
+                origin: event.origin ? String(event.origin) : null,
+                update,
+            });
+        };
+
+        const subscriptionIds = Object.entries(this._storage).reduce(
+            (map, [key, crdtType]) => {
+                const container = crdtType.value as Container;
+                const subscriptionId = container.subscribe(this.value, fn);
+
+                return map.set(key, subscriptionId);
+            },
+            new Map<string, number>(),
+        );
+
+        return () => {
+            Array.from(subscriptionIds.entries()).forEach(
+                ([key, subscriptionId]) => {
+                    const container = (this._storage[key]?.value ??
+                        null) as Container | null;
+
+                    if (!container) {
+                        throw new Error("Storage could not be found");
+                    }
+
+                    container.unsubscribe(this.value, subscriptionId);
+                },
+            );
+        };
+    }
+
+    /**
+     * TODO
+     * @description This method doesn't do anything yet.
+     */
+    public track(): this {
+        return this;
+    }
+
+    /**
+     * TODO
+     * @description This method doesn't do anything yet. The callback will still be executed.
+     */
+    public transact(fn: () => void): this {
+        fn();
+
+        return this;
+    }
+
+    /**
+     * TODO
+     * @description This method is not yet supported for loro
+     */
+    public undo(): this {
+        throw new Error("This is not yet supported");
+    }
+}

package/src/doc/CrdtLoroDocFactory.ts

@@ -0,0 +1,65 @@
+import type { AbstractCrdtType } from "@pluv/crdt";
+import { AbstractCrdtDocFactory } from "@pluv/crdt";
+import { CrdtLoroArray } from "../array";
+import { CrdtLoroMap } from "../map";
+import { CrdtLoroObject } from "../object";
+import { CrdtLoroText } from "../text";
+import { CrdtLoroDoc } from "./CrdtLoroDoc";
+
+export class CrdtLoroDocFactory<
+    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+> extends AbstractCrdtDocFactory<TStorage> {
+    private _initialStorage: () => TStorage;
+
+    constructor(initialStorage: () => TStorage = () => ({}) as TStorage) {
+        super();
+
+        this._initialStorage = initialStorage;
+    }
+
+    public getEmpty(): CrdtLoroDoc<TStorage> {
+        return new CrdtLoroDoc<TStorage>();
+    }
+
+    public getFactory(
+        initialStorage?: (() => TStorage) | undefined,
+    ): CrdtLoroDocFactory<TStorage> {
+        return new CrdtLoroDocFactory<TStorage>(
+            initialStorage ?? this._initialStorage,
+        );
+    }
+
+    public getFresh(): CrdtLoroDoc<TStorage> {
+        const storage = this._initialStorage();
+
+        return new CrdtLoroDoc<TStorage>(
+            Object.entries(storage).reduce((acc, [key, node]) => {
+                if (node instanceof CrdtLoroArray) {
+                    return { ...acc, [key]: new CrdtLoroArray([]) };
+                }
+
+                if (node instanceof CrdtLoroMap) {
+                    return { ...acc, [key]: new CrdtLoroMap([]) };
+                }
+
+                if (node instanceof CrdtLoroObject) {
+                    return { ...acc, [key]: new CrdtLoroObject({}) };
+                }
+
+                if (node instanceof CrdtLoroText) {
+                    return { ...acc, [key]: new CrdtLoroText("") };
+                }
+
+                return acc;
+            }, {} as TStorage),
+        );
+    }
+
+    public getInitialized(
+        initialStorage?: () => TStorage,
+    ): CrdtLoroDoc<TStorage> {
+        return new CrdtLoroDoc<TStorage>(
+            initialStorage?.() ?? this._initialStorage(),
+        );
+    }
+}

package/src/doc/doc.ts

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

package/src/doc/index.ts

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

package/src/index.ts

@@ -0,0 +1 @@
+export * as loro from "./loro";

package/src/loro.ts

@@ -0,0 +1,6 @@
+export { CrdtLoroArray, array } from "./array";
+export { CrdtLoroDoc, doc } from "./doc";
+export { CrdtLoroMap, map } from "./map";
+export { CrdtLoroObject, object } from "./object";
+export { CrdtLoroText, text } from "./text";
+export type { InferLoroJson, InferLoroType } from "./types";

package/src/map/CrdtLoroMap.ts

@@ -0,0 +1,90 @@
+import type { InferCrdtStorageJson } from "@pluv/crdt";
+import { AbstractCrdtType } from "@pluv/crdt";
+import { LoroMap } from "loro-crdt";
+import type { CrdtLoroDoc } from "../doc/CrdtLoroDoc";
+import { cloneType, getLoroContainerType, isWrapper } from "../shared";
+import type { InferLoroJson } from "../types";
+
+export class CrdtLoroMap<T extends unknown> extends AbstractCrdtType<
+    LoroMap<Record<string, T>>,
+    Record<string, InferLoroJson<T>>
+> {
+    public readonly initialValue: readonly (readonly [key: string, value: T])[];
+
+    private _doc: CrdtLoroDoc<any> | null = null;
+    private _initialized: boolean = false;
+    private _value: LoroMap<Record<string, T>> = new LoroMap();
+
+    constructor(value: readonly (readonly [key: string, value: T])[] = []) {
+        super();
+
+        this.initialValue = value.map(
+            ([k, v]) => [k, v] as [key: string, value: T],
+        );
+    }
+
+    public set doc(doc: CrdtLoroDoc<any>) {
+        if (this._doc) throw new Error("Cannot overwrite array doc");
+
+        this._doc = doc;
+    }
+
+    public get size(): number {
+        return this.value.size;
+    }
+
+    public get value(): LoroMap<Record<string, T>> {
+        return this._value;
+    }
+
+    public set value(value: LoroMap<Record<string, T>>) {
+        if (this._initialized) throw new Error("Cannot re-assign map");
+
+        this._initialized = true;
+        this._value = value;
+
+        cloneType({ source: this, target: this.value });
+    }
+
+    public delete(prop: string): this {
+        this._guardInitialized();
+
+        this.value.delete(prop);
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public set(prop: string, value: T): this {
+        this._guardInitialized();
+
+        if (!(value instanceof AbstractCrdtType)) {
+            this.value.set(prop, value);
+            this._doc?.value.commit();
+
+            return this;
+        }
+
+        if (!isWrapper(value)) {
+            throw new Error("This type is not yet supported");
+        }
+
+        const containerType = getLoroContainerType(value);
+        const container = this.value.setContainer(prop, containerType);
+
+        cloneType({ source: value, target: container as any });
+        if (this._doc) value.doc = this._doc;
+
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public toJson(): InferCrdtStorageJson<Record<string, InferLoroJson<T>>> {
+        return this.value.toJson();
+    }
+
+    private _guardInitialized(): void {
+        if (!this._initialized) throw new Error("Array is not yet initialized");
+    }
+}

package/src/map/index.ts

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

package/src/map/map.ts

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

package/src/object/CrdtLoroObject.ts

@@ -0,0 +1,79 @@
+import { AbstractCrdtType, type InferCrdtStorageJson } from "@pluv/crdt";
+import { LoroMap } from "loro-crdt";
+import type { CrdtLoroDoc } from "../doc/CrdtLoroDoc";
+import { cloneType, getLoroContainerType, isWrapper } from "../shared";
+import type { InferLoroJson } from "../types";
+
+export class CrdtLoroObject<
+    T extends Record<string, any>,
+> extends AbstractCrdtType<LoroMap<T>, InferLoroJson<T>> {
+    public readonly initialValue: readonly (readonly [key: string, value: T])[];
+
+    private _doc: CrdtLoroDoc<any> | null = null;
+    private _initialized: boolean = false;
+    private _value: LoroMap<T> = new LoroMap();
+
+    constructor(value: T) {
+        super();
+
+        this.initialValue = Object.entries(value).map(
+            ([k, v]) => [k, v] as [key: string, value: T],
+        );
+    }
+
+    public set doc(doc: CrdtLoroDoc<any>) {
+        if (this._doc) throw new Error("Cannot overwrite array doc");
+
+        this._doc = doc;
+    }
+
+    public get size(): number {
+        return this.value.size;
+    }
+
+    public get value(): LoroMap<T> {
+        return this._value;
+    }
+
+    public set value(value: LoroMap<T>) {
+        if (this._initialized) throw new Error("Cannot re-assign map");
+
+        this._initialized = true;
+        this._value = value;
+
+        cloneType({ source: this, target: this.value });
+    }
+
+    public set(prop: string, value: T): this {
+        this._guardInitialized();
+
+        if (!(value instanceof AbstractCrdtType)) {
+            this.value.set(prop, value);
+            this._doc?.value.commit();
+
+            return this;
+        }
+
+        if (!isWrapper(value)) {
+            throw new Error("This type is not yet supported");
+        }
+
+        const containerType = getLoroContainerType(value);
+        const container = this.value.setContainer(prop, containerType);
+
+        cloneType({ source: value, target: container as any });
+        if (this._doc) value.doc = this._doc;
+
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public toJson(): InferCrdtStorageJson<InferLoroJson<T>> {
+        return this.value.toJson() as InferCrdtStorageJson<InferLoroJson<T>>;
+    }
+
+    private _guardInitialized(): void {
+        if (!this._initialized) throw new Error("Array is not yet initialized");
+    }
+}

package/src/object/index.ts

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

package/src/object/object.ts

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