@pluv/crdt-loro 0.16.0

package/src/shared/cloneType.ts

@@ -0,0 +1,238 @@
+import { AbstractCrdtType } from "@pluv/crdt";
+import type { Container } from "loro-crdt";
+import { LoroList, LoroMap, LoroText } from "loro-crdt";
+import { CrdtLoroArray } from "../array";
+import { CrdtLoroMap } from "../map";
+import { CrdtLoroObject } from "../object";
+import { CrdtLoroText } from "../text";
+
+interface CloneArrayParams<T extends unknown> {
+    source: CrdtLoroArray<T>;
+    target: LoroList<T[]>;
+}
+
+interface CloneMapParams<T extends unknown> {
+    source: CrdtLoroMap<T>;
+    target: LoroMap<Record<string, T>>;
+}
+
+interface CloneObjectParams<T extends Record<string, any>> {
+    source: CrdtLoroObject<T>;
+    target: LoroMap<T>;
+}
+
+interface CloneTextParams {
+    source: CrdtLoroText;
+    target: LoroText;
+}
+
+type SourceType<TType extends Container> =
+    TType extends LoroList<(infer I)[]>
+        ? CrdtLoroArray<I>
+        : TType extends LoroMap<infer I>
+          ? CrdtLoroMap<I[keyof I]> | CrdtLoroObject<I>
+          : TType extends LoroText
+            ? CrdtLoroText
+            : never;
+
+export interface CloneTypeParams<TType extends Container> {
+    source: SourceType<TType>;
+    target: TType;
+}
+
+function cloneArray<T extends unknown>(params: CloneArrayParams<T>): void {
+    const { source, target } = params;
+
+    const items = source.initialValue;
+
+    items.forEach((item, i) => {
+        if (!(item instanceof AbstractCrdtType)) {
+            target.insert(i, item);
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroArray) {
+            const list = target.insertContainer(i, "List");
+
+            item.value = list;
+            cloneArray({ source: item, target: list });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroMap) {
+            const map = target.insertContainer(i, "Map");
+
+            item.value = map;
+            cloneMap({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroObject) {
+            const map = target.insertContainer(i, "Map");
+
+            item.value = map;
+            cloneObject({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroText) {
+            const text = target.insertContainer(i, "Text");
+
+            item.value = text;
+            cloneText({ source: item, target: text });
+
+            return;
+        }
+
+        throw new Error("This type is not yet supported");
+    });
+}
+
+function cloneMap<T extends unknown>(params: CloneMapParams<T>): void {
+    const { source, target } = params;
+
+    const items = source.initialValue;
+
+    items.forEach(([key, item]) => {
+        if (!(item instanceof AbstractCrdtType)) {
+            target.set(key, item);
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroArray) {
+            const list = target.setContainer(key, "List");
+
+            item.value = list;
+            cloneArray({ source: item, target: list });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroMap) {
+            const map = target.setContainer(key, "Map");
+
+            item.value = map;
+            cloneMap({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroObject) {
+            const map = target.setContainer(key, "Map");
+
+            item.value = map;
+            cloneObject({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroText) {
+            const text = target.setContainer(key, "Text");
+
+            item.value = text;
+            cloneText({ source: item, target: text });
+
+            return;
+        }
+
+        throw new Error("This type is not yet supported");
+    });
+}
+
+function cloneObject<T extends Record<string, any>>(
+    params: CloneObjectParams<T>,
+): void {
+    const { source, target } = params;
+
+    const items = source.initialValue;
+
+    items.forEach(([key, item]) => {
+        if (!(item instanceof AbstractCrdtType)) {
+            target.set(key, item);
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroArray) {
+            const list = target.setContainer(key, "List");
+
+            item.value = list;
+            cloneArray({ source: item, target: list });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroMap) {
+            const map = target.setContainer(key, "Map");
+
+            item.value = map;
+            cloneMap({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroObject) {
+            const map = target.setContainer(key, "Map");
+
+            item.value = map;
+            cloneObject({ source: item, target: map });
+
+            return;
+        }
+
+        if (item instanceof CrdtLoroText) {
+            const text = target.setContainer(key, "Text");
+
+            item.value = text;
+            cloneText({ source: item, target: text });
+
+            return;
+        }
+
+        throw new Error("This type is not yet supported");
+    });
+}
+
+function cloneText(params: CloneTextParams): void {
+    const { source, target } = params;
+
+    source.value = target;
+    source.insert(0, source.initalValue);
+}
+
+export const cloneType = <TType extends Container>(
+    params: CloneTypeParams<TType>,
+) => {
+    const { source, target } = params;
+
+    if (source instanceof CrdtLoroArray) {
+        cloneArray({ source, target: target as LoroList });
+
+        return;
+    }
+
+    if (source instanceof CrdtLoroMap) {
+        cloneMap({ source, target: target as LoroMap });
+
+        return;
+    }
+
+    if (source instanceof CrdtLoroObject) {
+        cloneObject({ source, target: target as LoroMap });
+
+        return;
+    }
+
+    if (source instanceof CrdtLoroText) {
+        cloneText({ source, target: target as LoroText });
+
+        return;
+    }
+
+    throw new Error("This type is not yet supported");
+};

package/src/shared/getLoroContainerType.ts

@@ -0,0 +1,22 @@
+import { AbstractCrdtType } from "@pluv/crdt";
+import { CrdtLoroArray } from "../array";
+import { CrdtLoroMap } from "../map";
+import { CrdtLoroObject } from "../object";
+import { CrdtLoroText } from "../text";
+
+export const getLoroContainerType = <T extends AbstractCrdtType<any, any>>(
+    value: T,
+): T extends CrdtLoroArray<any>
+    ? "List"
+    : T extends CrdtLoroMap<any> | CrdtLoroObject<any>
+      ? "Map"
+      : T extends CrdtLoroText
+        ? "Text"
+        : never => {
+    if (value instanceof CrdtLoroArray) return "List" as any;
+    if (value instanceof CrdtLoroMap) return "Map" as any;
+    if (value instanceof CrdtLoroObject) return "Map" as any;
+    if (value instanceof CrdtLoroText) return "Text" as any;
+
+    throw new Error("This type is not yet supported");
+};

package/src/shared/index.ts

@@ -0,0 +1,5 @@
+export { cloneType } from "./cloneType";
+export type { CloneTypeParams } from "./cloneType";
+export { getLoroContainerType } from "./getLoroContainerType";
+export { isWrapper } from "./isWrapper";
+export { toLoroValue } from "./toLoroValue";

package/src/shared/isWrapper.ts

@@ -0,0 +1,19 @@
+import { CrdtLoroArray } from "../array/CrdtLoroArray";
+import { CrdtLoroMap } from "../map/CrdtLoroMap";
+import { CrdtLoroObject } from "../object/CrdtLoroObject";
+import { CrdtLoroText } from "../text/CrdtLoroText";
+
+export const isWrapper = (
+    item: any,
+): item is
+    | CrdtLoroArray<any>
+    | CrdtLoroMap<any>
+    | CrdtLoroObject<any>
+    | CrdtLoroText => {
+    return (
+        item instanceof CrdtLoroArray ||
+        item instanceof CrdtLoroMap ||
+        item instanceof CrdtLoroObject ||
+        item instanceof CrdtLoroText
+    );
+};

package/src/shared/toLoroValue.ts

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

package/src/text/CrdtLoroText.ts

@@ -0,0 +1,68 @@
+import { AbstractCrdtType } from "@pluv/crdt";
+import { LoroText } from "loro-crdt";
+import type { CrdtLoroDoc } from "../doc/CrdtLoroDoc";
+import { cloneType } from "../shared";
+
+export class CrdtLoroText extends AbstractCrdtType<LoroText, string> {
+    public initalValue: string;
+
+    private _doc: CrdtLoroDoc<any> | null = null;
+    private _initialized: boolean = false;
+    private _value: LoroText = new LoroText();
+
+    constructor(value: string = "") {
+        super();
+
+        this.initalValue = value;
+        this.value = new LoroText();
+    }
+
+    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(): LoroText {
+        return this._value;
+    }
+
+    public set value(value: LoroText) {
+        if (this._initialized) throw new Error("Cannot re-assign text");
+
+        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, text: string): this {
+        this._guardInitialized();
+
+        this.value.insert(index, text);
+        this._doc?.value.commit();
+
+        return this;
+    }
+
+    public toJson(): string {
+        return this.value.toString();
+    }
+
+    private _guardInitialized(): void {
+        if (!this._initialized) throw new Error("Array is not yet initialized");
+    }
+}

package/src/text/index.ts

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

package/src/text/text.ts

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

package/src/types.ts

@@ -0,0 +1,40 @@
+import type { Json } from "@pluv/types";
+import type { LoroList, LoroMap, LoroText } from "loro-crdt";
+import type { CrdtLoroArray } from "./array";
+import type { CrdtLoroMap } from "./map";
+import type { CrdtLoroObject } from "./object";
+import type { CrdtLoroText } from "./text";
+
+export type InferLoroType<T extends unknown> =
+    T extends CrdtLoroArray<infer IType>
+        ? LoroList<IType[]>
+        : T extends CrdtLoroMap<infer IType>
+          ? LoroMap<Record<string, IType>>
+          : T extends CrdtLoroObject<infer IType>
+            ? LoroMap<IType>
+            : T extends CrdtLoroText
+              ? LoroText
+              : T extends Json
+                ? T
+                : never;
+
+export type InferLoroJson<T extends unknown> =
+    T extends CrdtLoroArray<infer IType>
+        ? InferLoroJson<IType>[]
+        : T extends CrdtLoroMap<infer IType>
+          ? Record<string, InferLoroJson<IType>>
+          : T extends CrdtLoroObject<infer IType>
+            ? { [P in keyof IType]: InferLoroJson<IType[P]> }
+            : T extends CrdtLoroText | LoroText
+              ? string
+              : T extends LoroList<infer IType>
+                ? InferLoroJson<IType>
+                : T extends LoroMap<infer IType>
+                  ? { [P in keyof IType]: InferLoroJson<IType[P]> }
+                  : T extends (infer IType)[]
+                    ? InferLoroJson<IType>[]
+                    : T extends Record<any, any>
+                      ? { [P in keyof T]: InferLoroJson<T[P]> }
+                      : T extends Json
+                        ? T
+                        : never;

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"lib": ["esnext"]
+	}
+}