@pluv/crdt-yjs 0.18.0 → 0.20.0

package/src/doc/CrdtYjsDoc.ts

@@ -1,14 +1,9 @@
-import type {
-    AbstractCrdtType,
-    DocApplyEncodedStateParams,
-    DocSubscribeCallbackParams,
-    InferCrdtStorageJson,
-} from "@pluv/crdt";
+import type { DocApplyEncodedStateParams, DocSubscribeCallbackParams, InferCrdtJson } from "@pluv/crdt";
 import { AbstractCrdtDoc } from "@pluv/crdt";
 import { fromUint8Array, toUint8Array } from "js-base64";
 import {
+    AbstractType,
     UndoManager,
-    AbstractType as YAbstractType,
     Array as YArray,
     Doc as YDoc,
     Map as YMap,
@@ -19,15 +14,15 @@ import {
     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> {
+import { YjsArray } from "../array/YjsArray";
+import { YjsMap } from "../map/YjsMap";
+import { YjsObject } from "../object/YjsObject";
+import { YjsText } from "../text/YjsText";
+import type { YjsType } from "../types";
+import { YjsXmlElement } from "../xmlElement/YjsXmlElement";
+import { YjsXmlText } from "../xmlText/YjsXmlText";
+
+export class CrdtYjsDoc<TStorage extends Record<string, YjsType<any, any>>> extends AbstractCrdtDoc<TStorage> {
     public value: YDoc = new YDoc();
 
     private _storage: TStorage;
@@ -37,71 +32,62 @@ export class CrdtYjsDoc<TStorage extends Record<string, AbstractCrdtType<any, an
         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));
+            if (node instanceof YjsArray) {
+                const yArray = this.value.getArray(key);
 
-                node.value = yArray;
+                !!node.initialValue?.length && yArray.insert(0, node.initialValue?.slice(0));
 
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yArray };
             }
 
-            if (node instanceof CrdtYjsMap || node instanceof CrdtYjsObject) {
-                const yMap = this.value.get(key, YMap) as YMap<any>;
-                node.initialValue.forEach(([k, v]) => {
+            if (node instanceof YjsMap) {
+                const yMap = this.value.getMap(key);
+
+                (node.initialValue ?? []).forEach(([k, v]) => {
                     yMap.set(k.toString(), v);
                 });
 
-                node.value = yMap;
-
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yMap };
             }
 
-            if (node instanceof CrdtYjsObject) {
-                const yMap = this.value.get(key, YMap) as YMap<any>;
-                node.initialValue.forEach(([k, v]) => {
+            if (node instanceof YjsObject) {
+                const yMap = this.value.getMap(key);
+
+                Object.entries(node.initialValue ?? {}).forEach(([k, v]) => {
                     yMap.set(k.toString(), v);
                 });
 
-                node.value = yMap;
-
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yMap };
             }
 
-            if (node instanceof CrdtYjsText) {
-                const yText = this.value.get(key, YText) as YText;
-                yText.insert(0, node.initialValue);
+            if (node instanceof YjsText) {
+                const yText = this.value.getText(key);
 
-                node.value = yText;
+                typeof node.initialValue === "string" && yText.insert(0, node.initialValue);
 
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yText };
             }
 
-            if (node instanceof CrdtYjsXmlElement) {
-                const yXmlElement = this.value.get(key, YXmlElement) as YXmlElement;
-                yXmlElement.insert(0, node.initialValue.slice(0));
+            if (node instanceof YjsXmlElement) {
+                const yXmlElement = this.value.getXmlElement(key);
 
-                node.value = yXmlElement;
+                !!node.initialValue?.length && yXmlElement.insert(0, node.initialValue?.slice(0));
 
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yXmlElement };
             }
 
-            if (node instanceof CrdtYjsXmlFragment) {
-                const yXmlFragment = this.value.get(key, YXmlFragment) as YXmlFragment;
-                yXmlFragment.insert(0, node.initialValue.slice(0));
+            if (node instanceof YXmlFragment) {
+                const yXmlFragment = this.value.getXmlFragment(key);
 
-                node.value = yXmlFragment;
+                !!node.initialValue?.length && yXmlFragment.insert(0, node.initialValue?.slice(0));
 
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yXmlFragment };
             }
 
-            if (node instanceof CrdtYjsXmlText) {
+            if (node instanceof YjsXmlText) {
                 const yXmlText = this.value.get(key, YXmlText) as YXmlText;
-                yXmlText.insert(0, node.initialValue);
-
-                node.value = yXmlText;
 
-                return { ...acc, [key]: node };
+                return { ...acc, [key]: yXmlText };
             }
 
             return acc;
@@ -156,11 +142,11 @@ export class CrdtYjsDoc<TStorage extends Record<string, AbstractCrdtType<any, an
     }
 
     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;
+    public get<TKey extends keyof TStorage>(type: TKey): TStorage[TKey];
+    public get<TKey extends keyof TStorage>(type?: TKey): TStorage | TStorage[TKey] {
+        if (typeof type === "undefined") return this._storage;
 
-        return this._storage[key as TKey];
+        return this._storage[type as TKey];
     }
 
     public getEncodedState(): string {
@@ -197,17 +183,16 @@ export class CrdtYjsDoc<TStorage extends Record<string, AbstractCrdtType<any, an
     public track(): this {
         if (this._undoManager) this._undoManager.destroy();
 
-        const sharedTypes = Object.values(this._storage).reduce<YAbstractType<any>[]>((acc, type) => {
+        const sharedTypes = Object.values(this._storage).reduce<YjsType<AbstractType<any>, 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
+                type instanceof YArray ||
+                type instanceof YMap ||
+                type instanceof YText ||
+                type instanceof YXmlElement ||
+                type instanceof YXmlFragment ||
+                type instanceof YXmlText
             ) {
-                acc.push(type.value);
+                acc.push(type);
             }
 
             return acc;
@@ -231,10 +216,14 @@ export class CrdtYjsDoc<TStorage extends Record<string, AbstractCrdtType<any, an
         return this;
     }
 
-    public toJson(): InferCrdtStorageJson<TStorage> {
+    public toJson(): InferCrdtJson<TStorage>;
+    public toJson<TKey extends keyof TStorage>(type: TKey): InferCrdtJson<TStorage[TKey]>;
+    public toJson<TKey extends keyof TStorage>(type?: TKey) {
+        if (typeof type === "string") return this._storage[type].toJSON();
+
         return Object.entries(this._storage).reduce(
-            (acc, [key, value]) => ({ ...acc, [key]: value.toJson() }),
-            {} as InferCrdtStorageJson<TStorage>,
+            (acc, [key, value]) => ({ ...(acc as any), [key]: value.toJSON() }),
+            {} as InferCrdtJson<TStorage>,
         );
     }
 

package/src/doc/CrdtYjsDocFactory.ts

@@ -1,16 +1,23 @@
-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 { XmlFragment as YXmlFragment } from "yjs";
+import { array } from "../array";
+import { YjsArray } from "../array/YjsArray";
+import { map } from "../map";
+import { YjsMap } from "../map/YjsMap";
+import { object } from "../object";
+import { YjsObject } from "../object/YjsObject";
+import { text } from "../text";
+import { YjsText } from "../text/YjsText";
+import type { YjsType } from "../types";
+import { xmlElement } from "../xmlElement";
+import { YjsXmlElement } from "../xmlElement/YjsXmlElement";
+import { xmlFragment } from "../xmlFragment";
+import { xmlText } from "../xmlText";
+import { YjsXmlText } from "../xmlText/YjsXmlText";
 import { CrdtYjsDoc } from "./CrdtYjsDoc";
 
 export class CrdtYjsDocFactory<
-    TStorage extends Record<string, AbstractCrdtType<any, any>>,
+    TStorage extends Record<string, YjsType<any, any>>,
 > extends AbstractCrdtDocFactory<TStorage> {
     private _initialStorage: () => TStorage;
 
@@ -33,35 +40,32 @@ export class CrdtYjsDocFactory<
 
         return new CrdtYjsDoc<TStorage>(
             Object.entries(storage).reduce((acc, [key, node]) => {
-                if (node instanceof CrdtYjsArray) {
-                    return { ...acc, [key]: new CrdtYjsArray([]) };
+                if (node instanceof YjsArray) {
+                    return { ...acc, [key]: array() };
                 }
 
-                if (node instanceof CrdtYjsMap) {
-                    return { ...acc, [key]: new CrdtYjsMap([]) };
+                if (node instanceof YjsMap) {
+                    return { ...acc, [key]: map() };
                 }
 
-                if (node instanceof CrdtYjsObject) {
-                    return { ...acc, [key]: new CrdtYjsObject({}) };
+                if (node instanceof YjsObject) {
+                    return { ...acc, [key]: object() };
                 }
 
-                if (node instanceof CrdtYjsText) {
-                    return { ...acc, [key]: new CrdtYjsText("") };
+                if (node instanceof YjsText) {
+                    return { ...acc, [key]: text() };
                 }
 
-                if (node instanceof CrdtYjsXmlElement) {
-                    return {
-                        ...acc,
-                        [key]: new CrdtYjsXmlElement(node.name, []),
-                    };
+                if (node instanceof YjsXmlElement) {
+                    return { ...acc, [key]: xmlElement(node.nodeName, []) };
                 }
 
-                if (node instanceof CrdtYjsXmlFragment) {
-                    return { ...acc, [key]: new CrdtYjsXmlFragment([]) };
+                if (node instanceof YXmlFragment) {
+                    return { ...acc, [key]: xmlFragment([]) };
                 }
 
-                if (node instanceof CrdtYjsXmlText) {
-                    return { ...acc, [key]: new CrdtYjsXmlText("") };
+                if (node instanceof YjsXmlText) {
+                    return { ...acc, [key]: xmlText() };
                 }
 
                 return acc;

package/src/doc/doc.ts

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

package/src/map/YjsMap.ts

@@ -0,0 +1,16 @@
+import { Map as YMap } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsMap<T extends unknown> extends YMap<T> implements YjsType<YMap<T>, Record<string, T>> {
+    public initialValue?: readonly (readonly [key: string, value: T])[];
+
+    constructor(value: readonly (readonly [key: string, value: T])[] = []) {
+        super(value);
+
+        this.initialValue = value;
+    }
+
+    public __pluvType(): any {
+        return {} as any;
+    }
+}

package/src/map/index.ts

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

package/src/map/map.ts

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

package/src/object/YjsObject.ts

@@ -0,0 +1,16 @@
+import { Map as YMap } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsObject<T extends Record<string, any>> extends YMap<T[keyof T]> implements YjsType<YMap<T[keyof T]>, T> {
+    public initialValue?: T;
+
+    constructor(value: T) {
+        super(Object.entries(value));
+
+        this.initialValue = value;
+    }
+
+    public __pluvType() {
+        return {} as unknown as any;
+    }
+}

package/src/object/index.ts

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

package/src/object/object.ts

@@ -1,5 +1,7 @@
-import { CrdtYjsObject } from "./CrdtYjsObject";
+import type { Map as YMap } from "yjs";
+import type { YjsType } from "../types";
+import { YjsObject } from "./YjsObject";
 
-export const object = <T extends Record<string, any>>(value: T): CrdtYjsObject<T> => {
-    return new CrdtYjsObject(value);
+export const object = <T extends Record<string, any>>(value: T = {} as T): YjsType<YMap<T[keyof T]>, T> => {
+    return new YjsObject<T>(value);
 };

package/src/text/YjsText.ts

@@ -0,0 +1,16 @@
+import { Text as YText } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsText extends YText implements YjsType<YText, string> {
+    public initialValue?: string;
+
+    constructor(value: string = "") {
+        super();
+
+        this.initialValue = value;
+    }
+
+    public __pluvType() {
+        return {} as unknown as any;
+    }
+}

package/src/text/index.ts

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

package/src/text/text.ts

@@ -1,5 +1,7 @@
-import { CrdtYjsText } from "./CrdtYjsText";
+import type { Text as YText } from "yjs";
+import type { YjsType } from "../types";
+import { YjsText } from "./YjsText";
 
-export const text = (value: string = ""): CrdtYjsText => {
-    return new CrdtYjsText(value);
+export const text = (value: string = ""): YjsType<YText, string> => {
+    return new YjsText(value);
 };

package/src/types.ts

@@ -1,64 +1,6 @@
-import type { Json } from "@pluv/types";
-import type {
-    Array as YArray,
-    Map as YMap,
-    Text as YText,
-    XmlElement as YXmlElement,
-    XmlFragment as YXmlFragment,
-    XmlText as YXmlText,
-} from "yjs";
-import type { CrdtYjsArray } from "./array";
-import type { CrdtYjsMap } from "./map";
-import type { CrdtYjsObject } from "./object";
-import type { CrdtYjsText } from "./text";
-import type { CrdtYjsXmlElement } from "./xmlElement";
-import type { CrdtYjsXmlFragment } from "./xmlFragment";
-import type { CrdtYjsXmlText } from "./xmlText";
+import type { CrdtType } from "@pluv/crdt";
 
-export type InferYjsType<T extends unknown> =
-    T extends CrdtYjsArray<infer IType>
-        ? YArray<IType>
-        : T extends CrdtYjsMap<infer IType>
-          ? YMap<IType>
-          : T extends CrdtYjsObject<infer IType>
-            ? YMap<IType[keyof IType]>
-            : T extends CrdtYjsText
-              ? YText
-              : T extends CrdtYjsXmlElement
-                ? YXmlElement
-                : T extends CrdtYjsXmlFragment
-                  ? YXmlFragment
-                  : T extends CrdtYjsXmlText
-                    ? YXmlText
-                    : T extends Json
-                      ? T
-                      : never;
-
-export type InferYjsJson<T extends unknown> =
-    T extends CrdtYjsArray<infer IType>
-        ? InferYjsJson<IType>[]
-        : T extends CrdtYjsMap<infer IType>
-          ? Record<string, InferYjsJson<IType>>
-          : T extends CrdtYjsObject<infer IType>
-            ? { [P in keyof IType]: InferYjsJson<IType[P]> }
-            : T extends
-                    | CrdtYjsText
-                    | CrdtYjsXmlElement
-                    | CrdtYjsXmlFragment
-                    | CrdtYjsXmlText
-                    | YText
-                    | YXmlElement
-                    | YXmlFragment
-                    | YXmlText
-              ? string
-              : T extends YArray<infer IType>
-                ? InferYjsJson<IType>[]
-                : T extends YMap<infer IType>
-                  ? Record<string, InferYjsJson<IType>>
-                  : T extends (infer IType)[]
-                    ? InferYjsJson<IType>[]
-                    : T extends Record<any, any>
-                      ? { [P in keyof T]: InferYjsJson<T[P]> }
-                      : T extends Json
-                        ? T
-                        : never;
+export type YjsType<TValue extends unknown, TJson extends unknown = any> = CrdtType<TValue, TJson> & {
+    initialValue?: any;
+    toJSON: () => any;
+};

package/src/xmlElement/YjsXmlElement.ts

@@ -0,0 +1,22 @@
+import type { XmlText as YXmlText } from "yjs";
+import { XmlElement as YXmlElement } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsXmlElement<T extends Record<string, any> = Record<string, any>>
+    extends YXmlElement<T>
+    implements YjsType<YXmlElement, string>
+{
+    public initialValue?: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[];
+
+    constructor(name: string, value: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[]) {
+        super(name);
+
+        !!value.length && this.insert(0, value as (YXmlElement | YXmlText)[]);
+
+        this.initialValue = value;
+    }
+
+    public __pluvType() {
+        return {} as unknown as any;
+    }
+}

package/src/xmlElement/index.ts

@@ -1,2 +1,2 @@
-export { CrdtYjsXmlElement } from "./CrdtYjsXmlElement";
 export { xmlElement } from "./xmlElement";
+export type { YjsXmlElement } from "./YjsXmlElement";

package/src/xmlElement/xmlElement.ts

@@ -1,9 +1,9 @@
-import type { CrdtYjsXmlText } from "../xmlText";
-import { CrdtYjsXmlElement } from "./CrdtYjsXmlElement";
+import type { XmlText as YXmlText, XmlElement as YXmlElement } from "yjs";
+import { YjsXmlElement } from "./YjsXmlElement";
 
-export const xmlElement = (
+export const xmlElement = <T extends Record<string, any> = Record<string, any>>(
     name: string,
-    children: readonly (CrdtYjsXmlElement | CrdtYjsXmlText)[],
-): CrdtYjsXmlElement => {
-    return new CrdtYjsXmlElement(name, children);
+    children: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[],
+): YjsXmlElement<T> => {
+    return new YjsXmlElement<T>(name, children);
 };

package/src/xmlFragment/YjsXmlFragment.ts

@@ -0,0 +1,19 @@
+import type { XmlText as YXmlText, XmlElement as YXmlElement } from "yjs";
+import { XmlFragment as YXmlFragment } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsXmlFragment extends YXmlFragment implements YjsType<YXmlFragment, string> {
+    public initialValue?: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[];
+
+    constructor(value: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[]) {
+        super();
+
+        !!value.length && this.insert(0, value as (YXmlElement | YXmlText)[]);
+
+        this.initialValue = value;
+    }
+
+    public __pluvType() {
+        return {} as unknown as any;
+    }
+}

package/src/xmlFragment/index.ts

@@ -1,2 +1,2 @@
-export { CrdtYjsXmlFragment } from "./CrdtYjsXmlFragment";
 export { xmlFragment } from "./xmlFragment";
+export type { YjsXmlFragment } from "./YjsXmlFragment";

package/src/xmlFragment/xmlFragment.ts

@@ -1,7 +1,8 @@
-import type { CrdtYjsXmlElement } from "../xmlElement";
-import type { CrdtYjsXmlText } from "../xmlText";
-import { CrdtYjsXmlFragment } from "./CrdtYjsXmlFragment";
+import type { XmlElement as YXmlElement, XmlText as YXmlText } from "yjs";
+import { YjsXmlFragment } from "./YjsXmlFragment";
 
-export const xmlFragment = (children: readonly (CrdtYjsXmlElement | CrdtYjsXmlText)[]): CrdtYjsXmlFragment => {
-    return new CrdtYjsXmlFragment(children);
+export const xmlFragment = (
+    children: (YXmlElement | YXmlText)[] | readonly (YXmlElement | YXmlText)[],
+): YjsXmlFragment => {
+    return new YjsXmlFragment(children);
 };

package/src/xmlText/YjsXmlText.ts

@@ -0,0 +1,16 @@
+import { XmlText as YXmlText } from "yjs";
+import type { YjsType } from "../types";
+
+export class YjsXmlText extends YXmlText implements YjsType<YXmlText, string> {
+    public initialValue?: string;
+
+    constructor(value: string = "") {
+        super();
+
+        this.initialValue = value;
+    }
+
+    public __pluvType() {
+        return {} as unknown as any;
+    }
+}

package/src/xmlText/index.ts

@@ -1,2 +1,2 @@
-export { CrdtYjsXmlText } from "./CrdtYjsXmlText";
 export { xmlText } from "./xmlText";
+export type { YjsXmlText } from "./YjsXmlText";

package/src/xmlText/xmlText.ts

@@ -1,5 +1,7 @@
-import { CrdtYjsXmlText } from "./CrdtYjsXmlText";
+import type { XmlText as YXmlText } from "yjs";
+import { YjsType } from "../types";
+import { YjsXmlText } from "./YjsXmlText";
 
-export const xmlText = (value: string = ""): CrdtYjsXmlText => {
-    return new CrdtYjsXmlText(value);
+export const xmlText = (): YjsType<YXmlText, string> => {
+    return new YjsXmlText();
 };

package/src/yjs.ts

@@ -1,9 +1,9 @@
-export { CrdtYjsArray, array } from "./array";
-export { CrdtYjsDoc, doc } from "./doc";
-export { CrdtYjsMap, map } from "./map";
-export { CrdtYjsObject, object } from "./object";
-export { CrdtYjsText } from "./text";
-export type { InferYjsJson, InferYjsType } from "./types";
-export { CrdtYjsXmlElement, xmlElement } from "./xmlElement";
-export { CrdtYjsXmlFragment, xmlFragment } from "./xmlFragment";
-export { CrdtYjsXmlText, xmlText } from "./xmlText";
+export { array } from "./array";
+export { doc } from "./doc";
+export { map } from "./map";
+export { object } from "./object";
+export { text } from "./text";
+export type { YjsType } from "./types";
+export { xmlElement } from "./xmlElement";
+export { xmlFragment } from "./xmlFragment";
+export { xmlText } from "./xmlText";