@pluv/crdt-yjs 0.0.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @pluv/crdt-yjs@0.0.0 build /home/runner/work/pluv/pluv/packages/crdt-yjs
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v6.5.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+CJS dist/index.js 4.01 KB
+CJS ⚡️ Build success in 54ms
+ESM dist/index.mjs 2.88 KB
+ESM ⚡️ Build success in 55ms
+DTS Build start
+DTS ⚡️ Build success in 1412ms
+DTS dist/index.d.ts 2.61 KB

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { Array, AbstractType, Doc, Transaction, Map, Text } from 'yjs';
+export { AbstractType, Array, Map, Text } from 'yjs';
+import { JsonObject, JsonPrimitive } from '@pluv/types';
+
+declare const array: <T extends unknown>(value?: readonly T[]) => Array<T>;
+
+declare class YjsDoc<T extends Record<string, AbstractType<any>> = {}> {
+    value: Doc;
+    private get _storage();
+    constructor(value?: T);
+    applyUpdate(update: string | Uint8Array, origin?: string): this;
+    destroy(): void;
+    encodeStateAsUpdate(): string;
+    get<TKey extends keyof T>(key: TKey): T[TKey];
+    getSharedTypes(): T;
+    subscribe(fn: (update: string, origin: string, doc: Doc, transaction: Transaction) => void): () => void;
+    toJSON(): JsonObject;
+    static fromUint8Array(u8a: Uint8Array): string;
+    static toUint8Array(str: string): Uint8Array;
+}
+declare const doc: <T extends Record<string, AbstractType<any>> = {}>(value?: T | undefined) => YjsDoc<T>;
+
+declare const map: <T extends unknown>(value?: readonly (readonly [key: string, value: T])[]) => Map<T>;
+
+type unstable__YObjectValue = Record<string, NonNullable<JsonPrimitive> | AbstractType<any>>;
+type unstable__YObject<T extends unstable__YObjectValue> = Map<T[keyof T]> & {
+    __$type: T;
+};
+declare const unstable__object: <T extends unstable__YObjectValue = {}>(value: T) => unstable__YObject<T>;
+
+declare const text: (value?: string) => Text;
+
+type InferYjsDocJson<TDoc extends YjsDoc<any>> = TDoc extends YjsDoc<infer ITypes> ? {
+    [P in keyof ITypes]: InferYjsSharedTypeJson<ITypes[P]>;
+} : never;
+type InferYjsDocSharedType<TDoc extends YjsDoc<any>, TKey extends keyof InferYjsDocSharedTypes<TDoc> = keyof InferYjsDocSharedTypes<TDoc>> = InferYjsDocSharedTypes<TDoc>[TKey];
+type InferYjsDocSharedTypeJson<TDoc extends YjsDoc<any>, TKey extends keyof InferYjsDocSharedTypes<TDoc> = keyof InferYjsDocSharedTypes<TDoc>> = InferYjsSharedTypeJson<InferYjsDocSharedTypes<TDoc>[TKey]>;
+type InferYjsDocSharedTypes<TDoc extends YjsDoc<any>> = TDoc extends YjsDoc<infer ITypes> ? ITypes : never;
+type InferYjsSharedTypeJson<TShared extends unknown> = TShared extends AbstractType<any> ? TShared extends Array<infer IItem> ? readonly InferYjsSharedTypeJson<IItem>[] : TShared extends unstable__YObject<infer IObject> ? {
+    [P in keyof IObject]: InferYjsSharedTypeJson<IObject[P]>;
+} : TShared extends Map<infer IItem> ? Record<string, InferYjsSharedTypeJson<IItem>> : TShared extends Text ? string : never : TShared;
+
+export { InferYjsDocJson, InferYjsDocSharedType, InferYjsDocSharedTypeJson, InferYjsDocSharedTypes, InferYjsSharedTypeJson, YjsDoc, array, doc, map, text, unstable__YObject, unstable__object };

package/dist/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  YjsDoc: () => YjsDoc,
+  array: () => array,
+  doc: () => doc,
+  map: () => map,
+  text: () => text,
+  unstable__object: () => unstable__object
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/array.ts
+var import_yjs = require("yjs");
+var array = (value = []) => {
+  const yarray = new import_yjs.Array();
+  yarray.push(value.slice());
+  return yarray;
+};
+
+// src/doc.ts
+var import_js_base64 = require("js-base64");
+var import_yjs2 = require("yjs");
+var YjsDoc = class {
+  constructor(value) {
+    this.value = new import_yjs2.Doc();
+    if (!value)
+      return;
+    const storage = this.value.getMap("storage");
+    Object.entries(value).forEach(([key, node]) => {
+      storage.set(key, node);
+    });
+  }
+  get _storage() {
+    return this.value.getMap("storage");
+  }
+  applyUpdate(update, origin) {
+    const uint8Update = typeof update === "string" ? (0, import_js_base64.toUint8Array)(update) : update;
+    (0, import_yjs2.applyUpdate)(this.value, uint8Update, origin);
+    return this;
+  }
+  destroy() {
+    this.value.destroy();
+  }
+  encodeStateAsUpdate() {
+    return (0, import_js_base64.fromUint8Array)((0, import_yjs2.encodeStateAsUpdate)(this.value));
+  }
+  get(key) {
+    return this._storage.get(key.toString());
+  }
+  getSharedTypes() {
+    return Array.from(this._storage.keys()).reduce(
+      (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: this._storage.get(key) }),
+      {}
+    );
+  }
+  subscribe(fn) {
+    const _fn = (update, origin, doc2, transaction) => fn(YjsDoc.fromUint8Array(update), origin, doc2, transaction);
+    this.value.on("update", _fn);
+    return () => {
+      this.value.off("update", _fn);
+    };
+  }
+  toJSON() {
+    return this._storage.toJSON();
+  }
+  static fromUint8Array(u8a) {
+    return (0, import_js_base64.fromUint8Array)(u8a);
+  }
+  static toUint8Array(str) {
+    return (0, import_js_base64.toUint8Array)(str);
+  }
+};
+var doc = (value) => {
+  return new YjsDoc(value);
+};
+
+// src/map.ts
+var import_yjs3 = require("yjs");
+var map = (value = []) => {
+  return new import_yjs3.Map(value);
+};
+
+// src/object.ts
+var import_yjs4 = require("yjs");
+var unstable__object = (value) => {
+  return new import_yjs4.Map(Object.entries(value));
+};
+
+// src/text.ts
+var import_yjs5 = require("yjs");
+var text = (value = "") => {
+  return new import_yjs5.Text(value);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YjsDoc,
+  array,
+  doc,
+  map,
+  text,
+  unstable__object
+});

package/dist/index.mjs

@@ -0,0 +1,110 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/array.ts
+import { Array as YArray } from "yjs";
+var array = (value = []) => {
+  const yarray = new YArray();
+  yarray.push(value.slice());
+  return yarray;
+};
+
+// src/doc.ts
+import { fromUint8Array, toUint8Array } from "js-base64";
+import { applyUpdate, Doc as YDoc, encodeStateAsUpdate } from "yjs";
+var YjsDoc = class {
+  constructor(value) {
+    this.value = new YDoc();
+    if (!value)
+      return;
+    const storage = this.value.getMap("storage");
+    Object.entries(value).forEach(([key, node]) => {
+      storage.set(key, node);
+    });
+  }
+  get _storage() {
+    return this.value.getMap("storage");
+  }
+  applyUpdate(update, origin) {
+    const uint8Update = typeof update === "string" ? toUint8Array(update) : update;
+    applyUpdate(this.value, uint8Update, origin);
+    return this;
+  }
+  destroy() {
+    this.value.destroy();
+  }
+  encodeStateAsUpdate() {
+    return fromUint8Array(encodeStateAsUpdate(this.value));
+  }
+  get(key) {
+    return this._storage.get(key.toString());
+  }
+  getSharedTypes() {
+    return Array.from(this._storage.keys()).reduce(
+      (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: this._storage.get(key) }),
+      {}
+    );
+  }
+  subscribe(fn) {
+    const _fn = (update, origin, doc2, transaction) => fn(YjsDoc.fromUint8Array(update), origin, doc2, transaction);
+    this.value.on("update", _fn);
+    return () => {
+      this.value.off("update", _fn);
+    };
+  }
+  toJSON() {
+    return this._storage.toJSON();
+  }
+  static fromUint8Array(u8a) {
+    return fromUint8Array(u8a);
+  }
+  static toUint8Array(str) {
+    return toUint8Array(str);
+  }
+};
+var doc = (value) => {
+  return new YjsDoc(value);
+};
+
+// src/map.ts
+import { Map as YMap } from "yjs";
+var map = (value = []) => {
+  return new YMap(value);
+};
+
+// src/object.ts
+import { Map as YMap2 } from "yjs";
+var unstable__object = (value) => {
+  return new YMap2(Object.entries(value));
+};
+
+// src/text.ts
+import { Text as YText } from "yjs";
+var text = (value = "") => {
+  return new YText(value);
+};
+export {
+  YjsDoc,
+  array,
+  doc,
+  map,
+  text,
+  unstable__object
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@pluv/crdt-yjs",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pluv/types": "^0.0.0",
+    "js-base64": "^3.7.3"
+  },
+  "peerDependencies": {
+    "yjs": "^13.0.0"
+  },
+  "devDependencies": {
+    "@pluv/tsconfig": "^0.0.0",
+    "eslint-config-pluv": "^0.0.0",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4",
+    "yjs": "^13.5.44"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/array.ts

@@ -0,0 +1,11 @@
+import { Array as YArray } from "yjs";
+
+export const array = <T extends unknown>(
+    value: readonly T[] = []
+): YArray<T> => {
+    const yarray = new YArray<T>();
+
+    yarray.push(value.slice());
+
+    return yarray;
+};

package/src/doc.ts

@@ -0,0 +1,90 @@
+import type { JsonObject } from "@pluv/types";
+import { fromUint8Array, toUint8Array } from "js-base64";
+import type { AbstractType, Map as YMap, Transaction } from "yjs";
+import { applyUpdate, Doc as YDoc, encodeStateAsUpdate } from "yjs";
+
+export class YjsDoc<T extends Record<string, AbstractType<any>> = {}> {
+    public value: YDoc = new YDoc();
+
+    private get _storage(): YMap<any> {
+        return this.value.getMap("storage");
+    }
+
+    constructor(value?: T) {
+        if (!value) return;
+
+        const storage = this.value.getMap("storage");
+
+        Object.entries(value).forEach(([key, node]) => {
+            storage.set(key, node);
+        });
+    }
+
+    public applyUpdate(update: string | Uint8Array, origin?: string): this {
+        const uint8Update =
+            typeof update === "string" ? toUint8Array(update) : update;
+
+        applyUpdate(this.value, uint8Update, origin);
+
+        return this;
+    }
+
+    public destroy(): void {
+        this.value.destroy();
+    }
+
+    public encodeStateAsUpdate(): string {
+        return fromUint8Array(encodeStateAsUpdate(this.value));
+    }
+
+    public get<TKey extends keyof T>(key: TKey): T[TKey] {
+        return this._storage.get(key.toString());
+    }
+
+    public getSharedTypes(): T {
+        return Array.from(this._storage.keys()).reduce(
+            (acc, key) => ({ ...acc, [key]: this._storage.get(key) }),
+            {} as T
+        );
+    }
+
+    public subscribe(
+        fn: (
+            update: string,
+            origin: string,
+            doc: YDoc,
+            transaction: Transaction
+        ) => void
+    ): () => void {
+        const _fn = (
+            update: Uint8Array,
+            origin: string,
+            doc: YDoc,
+            transaction: Transaction
+        ) => fn(YjsDoc.fromUint8Array(update), origin, doc, transaction);
+
+        this.value.on("update", _fn);
+
+        return () => {
+            this.value.off("update", _fn);
+        };
+    }
+
+    public toJSON(): JsonObject {
+        return this._storage.toJSON();
+    }
+
+    public static fromUint8Array(u8a: Uint8Array): string {
+        return fromUint8Array(u8a);
+    }
+
+    public static toUint8Array(str: string): Uint8Array {
+        return toUint8Array(str);
+    }
+}
+
+export const doc = <T extends Record<string, AbstractType<any>> = {}>(
+    value?: T
+): YjsDoc<T> => {
+    return new YjsDoc(value);
+};

package/src/index.ts

@@ -0,0 +1,14 @@
+export type { AbstractType, Array, Map, Text } from "yjs";
+export { array } from "./array";
+export { doc, YjsDoc } from "./doc";
+export { map } from "./map";
+export type { unstable__YObject } from "./object";
+export { unstable__object } from "./object";
+export { text } from "./text";
+export type {
+    InferYjsDocJson,
+    InferYjsDocSharedType,
+    InferYjsDocSharedTypeJson,
+    InferYjsDocSharedTypes,
+    InferYjsSharedTypeJson,
+} from "./types";

package/src/map.ts

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

package/src/object.ts

@@ -0,0 +1,18 @@
+import type { JsonPrimitive } from "@pluv/types";
+import type { AbstractType } from "yjs";
+import { Map as YMap } from "yjs";
+
+export type unstable__YObjectValue = Record<
+    string,
+    NonNullable<JsonPrimitive> | AbstractType<any>
+>;
+
+export type unstable__YObject<T extends unstable__YObjectValue> = YMap<
+    T[keyof T]
+> & { __$type: T };
+
+export const unstable__object = <T extends unstable__YObjectValue = {}>(
+    value: T
+): unstable__YObject<T> => {
+    return new YMap(Object.entries(value)) as unstable__YObject<T>;
+};

package/src/text.ts

@@ -0,0 +1,5 @@
+import { Text as YText } from "yjs";
+
+export const text = (value: string = ""): YText => {
+    return new YText(value);
+};

package/src/types.ts

@@ -0,0 +1,40 @@
+import type {
+    AbstractType,
+    Array as YArray,
+    Map as YMap,
+    Text as YText,
+} from "yjs";
+import type { YjsDoc } from "./doc";
+import type { unstable__YObject } from "./object";
+
+export type InferYjsDocJson<TDoc extends YjsDoc<any>> = TDoc extends YjsDoc<
+    infer ITypes
+>
+    ? { [P in keyof ITypes]: InferYjsSharedTypeJson<ITypes[P]> }
+    : never;
+
+export type InferYjsDocSharedType<
+    TDoc extends YjsDoc<any>,
+    TKey extends keyof InferYjsDocSharedTypes<TDoc> = keyof InferYjsDocSharedTypes<TDoc>
+> = InferYjsDocSharedTypes<TDoc>[TKey];
+
+export type InferYjsDocSharedTypeJson<
+    TDoc extends YjsDoc<any>,
+    TKey extends keyof InferYjsDocSharedTypes<TDoc> = keyof InferYjsDocSharedTypes<TDoc>
+> = InferYjsSharedTypeJson<InferYjsDocSharedTypes<TDoc>[TKey]>;
+
+export type InferYjsDocSharedTypes<TDoc extends YjsDoc<any>> =
+    TDoc extends YjsDoc<infer ITypes> ? ITypes : never;
+
+export type InferYjsSharedTypeJson<TShared extends unknown> =
+    TShared extends AbstractType<any>
+        ? TShared extends YArray<infer IItem>
+            ? readonly InferYjsSharedTypeJson<IItem>[]
+            : TShared extends unstable__YObject<infer IObject>
+            ? { [P in keyof IObject]: InferYjsSharedTypeJson<IObject[P]> }
+            : TShared extends YMap<infer IItem>
+            ? Record<string, InferYjsSharedTypeJson<IItem>>
+            : TShared extends YText
+            ? string
+            : never
+        : TShared;

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"]
+	}
+}