rhine-var 0.1.0

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/rhine-var.iml" filepath="$PROJECT_DIR$/.idea/rhine-var.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/rhine-var.iml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/dist" />
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/README.md

@@ -0,0 +1,42 @@
+
+# Most concise and rigorous strongly-typed collaborative library for multiple users
+
+Variables that support multi-user collaboration and persistence, making collaboration and variable operations as simple as possible, with strict and well-defined type hints.
+
+## Install
+```bash
+npm i rhine-var
+```
+
+## Usage
+
+
+```typescript jsx
+const defaultValue = {value: 0}
+const count = rhineProxy(defaultValue, 'RhineAI.com/ws/room-0')
+
+function EasyCounter() {
+
+  const countSnap = useRhine(count)
+
+  return <div className='page'>
+    <button onClick={() => count.value-- }> - 1 </button>
+    <span>{countSnap.value}</span>
+    <button onClick={() => count.value++ }> + 1 </button>
+  </div>
+}
+```
+
+<br/>
+
+## Develop With US
+
+Start Debug Mode
+
+```bash
+npm run watch
+cd test/debug/next-app
+npm run dev
+```
+
+<br/>

package/dist/core/class/array/RhineArray.d.ts

@@ -0,0 +1,3 @@
+export default class RhineArray<T> {
+}
+//# sourceMappingURL=RhineArray.d.ts.map

package/dist/core/class/array/RhineArray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RhineArray.d.ts","sourceRoot":"","sources":["../../../../src/core/class/array/RhineArray.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,OAAO,OAAO,UAAU,CAAC,CAAC;CAEhC"}

package/dist/core/class/array/RhineArray.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class RhineArray {
+}
+exports.default = RhineArray;

package/dist/core/connector/ConnectorStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum ConnectorStatus {
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    DISCONNECTED = "disconnected"
+}
+//# sourceMappingURL=ConnectorStatus.d.ts.map

package/dist/core/connector/ConnectorStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConnectorStatus.d.ts","sourceRoot":"","sources":["../../../src/core/connector/ConnectorStatus.ts"],"names":[],"mappings":"AACA,oBAAY,eAAe;IACzB,UAAU,eAAe;IACzB,SAAS,cAAc;IACvB,YAAY,iBAAiB;CAC9B"}

package/dist/core/connector/ConnectorStatus.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorStatus = void 0;
+var ConnectorStatus;
+(function (ConnectorStatus) {
+    ConnectorStatus["CONNECTING"] = "connecting";
+    ConnectorStatus["CONNECTED"] = "connected";
+    ConnectorStatus["DISCONNECTED"] = "disconnected";
+})(ConnectorStatus || (exports.ConnectorStatus = ConnectorStatus = {}));

package/dist/core/connector/WebsocketRhineConnector.d.ts

@@ -0,0 +1,25 @@
+import { Map as YMap, Doc as YDoc } from "yjs";
+import { WebsocketProvider } from "y-websocket";
+import { ConnectorStatus } from "./ConnectorStatus";
+import { Native } from "../native/Native";
+export type SyncedListener = (synced: boolean) => void;
+export default class WebsocketRhineConnector {
+    static STATE_KEY: string;
+    yDoc: YDoc;
+    yBaseMap: YMap<any>;
+    url: string;
+    clientId: number;
+    synced: boolean;
+    provider: WebsocketProvider | null;
+    websocketStatus: ConnectorStatus;
+    syncedListeners: SyncedListener[];
+    addSyncedListener(listener: SyncedListener): void;
+    removeSyncedListener(listener: SyncedListener): void;
+    emitSynced(synced: boolean): void;
+    waitSynced(): Promise<void>;
+    constructor(url?: string);
+    bind(defaultValue: Native, overwrite?: boolean): any;
+    connect(url: string): Promise<void>;
+}
+export declare function websocketRhineConnect(url: string): WebsocketRhineConnector;
+//# sourceMappingURL=WebsocketRhineConnector.d.ts.map

package/dist/core/connector/WebsocketRhineConnector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebsocketRhineConnector.d.ts","sourceRoot":"","sources":["../../../src/core/connector/WebsocketRhineConnector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,IAAI,IAAI,EAAmB,GAAG,IAAI,IAAI,EAAC,MAAM,KAAK,CAAC;AAC9D,OAAO,EAAC,iBAAiB,EAAC,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAC,eAAe,EAAC,0BAAyC;AAEjE,OAAO,EAAC,MAAM,EAAC,yBAA6B;AAE5C,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;AAEtD,MAAM,CAAC,OAAO,OAAO,uBAAuB;IAE1C,MAAM,CAAC,SAAS,SAAU;IAE1B,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,CAAA;IACnB,GAAG,EAAE,MAAM,CAAK;IAEhB,QAAQ,SAAK;IACb,MAAM,UAAQ;IAEd,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAAO;IACzC,eAAe,EAAE,eAAe,CAA+B;IAG/D,eAAe,EAAE,cAAc,EAAE,CAAK;IACtC,iBAAiB,CAAC,QAAQ,EAAE,cAAc;IAG1C,oBAAoB,CAAC,QAAQ,EAAE,cAAc;IAG7C,UAAU,CAAC,MAAM,EAAE,OAAO;IAI1B,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;gBAcf,GAAG,SAAK;IAMpB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,SAAS,GAAE,OAAe;IAc/C,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CA4C1C;AAGD,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,2BAMhD"}

package/dist/core/connector/WebsocketRhineConnector.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.websocketRhineConnect = websocketRhineConnect;
+const yjs_1 = require("yjs");
+const y_websocket_1 = require("y-websocket");
+const ConnectorStatus_1 = require("./ConnectorStatus");
+const Logger_1 = require("../utils/Logger");
+class WebsocketRhineConnector {
+    addSyncedListener(listener) {
+        this.syncedListeners.push(listener);
+    }
+    removeSyncedListener(listener) {
+        this.syncedListeners = this.syncedListeners.filter(l => l !== listener);
+    }
+    emitSynced(synced) {
+        this.syncedListeners.forEach(listener => listener(synced));
+    }
+    waitSynced() {
+        return new Promise((resolve) => {
+            if (this.synced)
+                return true;
+            const listener = (synced) => {
+                if (synced) {
+                    this.removeSyncedListener(listener);
+                    resolve();
+                }
+            };
+            this.addSyncedListener(listener);
+        });
+    }
+    constructor(url = '') {
+        this.url = '';
+        this.clientId = -1;
+        this.synced = false;
+        this.provider = null;
+        this.websocketStatus = ConnectorStatus_1.ConnectorStatus.DISCONNECTED;
+        this.syncedListeners = [];
+        this.yDoc = new yjs_1.Doc();
+        this.yBaseMap = this.yDoc.getMap();
+        url && this.connect(url);
+    }
+    bind(defaultValue, overwrite = false) {
+        if (this.synced) {
+            if (!overwrite && this.yBaseMap.has(WebsocketRhineConnector.STATE_KEY)) {
+                return this.yBaseMap.get(WebsocketRhineConnector.STATE_KEY);
+            }
+            this.yBaseMap.set(WebsocketRhineConnector.STATE_KEY, defaultValue);
+            return defaultValue;
+        }
+        else {
+            const tempMap = new yjs_1.Doc().getMap();
+            tempMap.set(WebsocketRhineConnector.STATE_KEY, defaultValue);
+            return defaultValue;
+        }
+    }
+    async connect(url) {
+        this.url = url;
+        let li = this.url.lastIndexOf('/');
+        if (li == -1 || li == this.url.length - 1 || !this.url.startsWith('ws')) {
+            console.error('UnSupport URL for Connect Room');
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.provider = new y_websocket_1.WebsocketProvider(this.url.slice(0, li), this.url.slice(li + 1), this.yDoc);
+            this.provider.shouldConnect = true;
+            this.provider.on('status', (event) => {
+                this.websocketStatus = event.status;
+                (0, Logger_1.log)('WebsocketRhineConnector.event status:', event.status);
+            });
+            this.provider.on('sync', (synced) => {
+                (0, Logger_1.log)('WebsocketRhineConnector.event sync:', synced);
+                if (synced) {
+                    this.synced = true;
+                    this.clientId = this.yDoc.clientID;
+                    this.emitSynced(synced);
+                    resolve();
+                }
+            });
+            this.provider.on('connection-close', (e) => {
+                this.websocketStatus = ConnectorStatus_1.ConnectorStatus.DISCONNECTED;
+                (0, Logger_1.log)('WebsocketRhineConnector.event connection-close:', e);
+            });
+            this.provider.on('connection-error', (error) => {
+                this.websocketStatus = ConnectorStatus_1.ConnectorStatus.DISCONNECTED;
+                (0, Logger_1.log)('WebsocketRhineConnector.event connection-error:', error);
+            });
+        });
+    }
+}
+WebsocketRhineConnector.STATE_KEY = 'state';
+exports.default = WebsocketRhineConnector;
+function websocketRhineConnect(url) {
+    const connector = new WebsocketRhineConnector();
+    if (typeof window !== 'undefined') {
+        connector.connect(url);
+    }
+    return connector;
+}

package/dist/core/event/Callback.d.ts

@@ -0,0 +1,4 @@
+import { ChangeType } from "./ChangeType";
+import { Transaction, YArrayEvent, YMapEvent } from "yjs";
+export type Callback = (value: any, key: string, oldValue: any, type: ChangeType, nativeEvent: YMapEvent<any> | YArrayEvent<any>, nativeTransaction: Transaction) => void;
+//# sourceMappingURL=Callback.d.ts.map

package/dist/core/event/Callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Callback.d.ts","sourceRoot":"","sources":["../../../src/core/event/Callback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,qBAAgC;AACnD,OAAO,EAAC,WAAW,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,KAAK,CAAC;AAExD,MAAM,MAAM,QAAQ,GAAG,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,iBAAiB,EAAE,WAAW,KAAK,IAAI,CAAA"}

package/dist/core/event/Callback.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/event/ChangeType.d.ts

@@ -0,0 +1,6 @@
+export declare enum ChangeType {
+    Add = "add",
+    Update = "update",
+    Delete = "delete"
+}
+//# sourceMappingURL=ChangeType.d.ts.map

package/dist/core/event/ChangeType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChangeType.d.ts","sourceRoot":"","sources":["../../../src/core/event/ChangeType.ts"],"names":[],"mappings":"AACA,oBAAY,UAAU;IACpB,GAAG,QAAQ;IACX,MAAM,WAAW;IACjB,MAAM,WAAW;CAClB"}

package/dist/core/event/ChangeType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeType = void 0;
+var ChangeType;
+(function (ChangeType) {
+    ChangeType["Add"] = "add";
+    ChangeType["Update"] = "update";
+    ChangeType["Delete"] = "delete";
+})(ChangeType || (exports.ChangeType = ChangeType = {}));

package/dist/core/native/Native.d.ts

@@ -0,0 +1,3 @@
+import { Array as YArray, Map as YMap } from "yjs";
+export type Native = YMap<any> | YArray<any>;
+//# sourceMappingURL=Native.d.ts.map

package/dist/core/native/Native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Native.d.ts","sourceRoot":"","sources":["../../../src/core/native/Native.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,IAAI,MAAM,EAAE,GAAG,IAAI,IAAI,EAAC,MAAM,KAAK,CAAC;AAEjD,MAAM,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA"}

package/dist/core/native/Native.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/native/NativeUtils.d.ts

@@ -0,0 +1,8 @@
+import { Map as YMap, Array as YArray } from "yjs";
+import { Native } from "./Native";
+export declare function isYMapOrYArray(value: any): value is YMap<any> | YArray<any>;
+export declare function nativeSet(target: Native, key: string | symbol, value: any): boolean;
+export declare function nativeDelete(target: Native, key: string | symbol): boolean;
+export declare function nativeGet(target: Native, key: string | symbol): any;
+export declare function jsonToNative(data: any): any;
+//# sourceMappingURL=NativeUtils.d.ts.map

package/dist/core/native/NativeUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeUtils.d.ts","sourceRoot":"","sources":["../../../src/core/native/NativeUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,IAAI,IAAI,EAAE,KAAK,IAAI,MAAM,EAAC,MAAM,KAAK,CAAA;AAChD,OAAO,EAAC,MAAM,EAAC,iBAA6B;AAI5C,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,oCAExC;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,WAuBzE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,WAwBhE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,OAgB7D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,GAAG,OAgBrC"}

package/dist/core/native/NativeUtils.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isYMapOrYArray = isYMapOrYArray;
+exports.nativeSet = nativeSet;
+exports.nativeDelete = nativeDelete;
+exports.nativeGet = nativeGet;
+exports.jsonToNative = jsonToNative;
+const yjs_1 = require("yjs");
+const DataUtils_1 = require("../utils/DataUtils");
+function isYMapOrYArray(value) {
+    return (value instanceof yjs_1.Map) || (value instanceof yjs_1.Array);
+}
+function nativeSet(target, key, value) {
+    if (typeof key !== 'string') {
+        return false;
+    }
+    try {
+        if (target instanceof yjs_1.Map) {
+            target.set(key, value);
+            return true;
+        }
+        else if (target instanceof yjs_1.Array) {
+            const index = parseInt(key);
+            if (!isNaN(index)) {
+                if (target.length - 1 >= index) {
+                    target.delete(index, 1);
+                }
+                target.insert(index, [value]);
+                return true;
+            }
+        }
+    }
+    catch (e) {
+        console.error('RhineVar nativeSet.error:', e);
+    }
+    return false;
+}
+function nativeDelete(target, key) {
+    if (typeof key !== 'string') {
+        return false;
+    }
+    try {
+        if (target instanceof yjs_1.Map) {
+            if (target.has(key)) {
+                target.delete(key);
+                return true;
+            }
+        }
+        if (target instanceof yjs_1.Array) {
+            const pn = parseInt(key);
+            if (!isNaN(pn)) {
+                if (target.length > pn && pn >= 0) {
+                    target.delete(pn, 1);
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.error('RhineVar nativeDelete.error:', e);
+    }
+    return false;
+}
+function nativeGet(target, key) {
+    if (typeof key !== 'string') {
+        return undefined;
+    }
+    try {
+        if (target instanceof yjs_1.Map) {
+            return target.get(key);
+        }
+        else if (target instanceof yjs_1.Array) {
+            const pn = parseInt(key);
+            if (!isNaN(pn))
+                return target.get(pn);
+        }
+    }
+    catch (e) {
+        console.error('RhineVar nativeGet.error:', e);
+    }
+    return undefined;
+}
+function jsonToNative(data) {
+    if ((0, DataUtils_1.isObject)(data)) {
+        let map = new yjs_1.Map();
+        Object.entries(data).forEach(([key, value]) => {
+            map.set(key, jsonToNative(value));
+        });
+        return map;
+    }
+    if ((0, DataUtils_1.isArray)(data)) {
+        let array = new yjs_1.Array();
+        data.forEach((value, index) => {
+            array.push([jsonToNative(value)]);
+        });
+        return array;
+    }
+    return data;
+}

package/dist/core/proxy/DirectPackage.d.ts

@@ -0,0 +1,6 @@
+export default class DirectPackage {
+    data: any;
+    constructor(data: any);
+}
+export declare function directPackage(data: any): DirectPackage;
+//# sourceMappingURL=DirectPackage.d.ts.map

package/dist/core/proxy/DirectPackage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DirectPackage.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/DirectPackage.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,OAAO,OAAO,aAAa;IAEvB,IAAI,EAAE,GAAG;gBAAT,IAAI,EAAE,GAAG;CAEnB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,GAAG,iBAEtC"}

package/dist/core/proxy/DirectPackage.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directPackage = directPackage;
+class DirectPackage {
+    constructor(data) {
+        this.data = data;
+    }
+}
+exports.default = DirectPackage;
+function directPackage(data) {
+    return new DirectPackage(data);
+}

package/dist/core/proxy/ProxiedRhineVar.d.ts

@@ -0,0 +1,6 @@
+import RhineVar from "./RhineVar";
+export type RecursiveCrossRhineVar<T> = {
+    [K in keyof T]: T[K] extends object ? RecursiveCrossRhineVar<T[K]> & RhineVar : T[K];
+};
+export type ProxiedRhineVar<T> = T & RecursiveCrossRhineVar<T> & RhineVar;
+//# sourceMappingURL=ProxiedRhineVar.d.ts.map

package/dist/core/proxy/ProxiedRhineVar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProxiedRhineVar.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/ProxiedRhineVar.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,mBAA8B;AAE7C,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI;KACrC,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,CAAC;CACrF,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAA"}

package/dist/core/proxy/ProxiedRhineVar.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/proxy/Proxy.d.ts

@@ -0,0 +1,6 @@
+import WebsocketRhineConnector from "../connector/WebsocketRhineConnector";
+import { ProxiedRhineVar } from "./ProxiedRhineVar";
+import { Native } from "../native/Native";
+export declare function rhineProxy<T extends object>(data: T, connector?: WebsocketRhineConnector | string | null, overwrite?: boolean): ProxiedRhineVar<T>;
+export declare function rhineProxyNative<T extends object>(target: Native): ProxiedRhineVar<T>;
+//# sourceMappingURL=Proxy.d.ts.map

package/dist/core/proxy/Proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Proxy.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/Proxy.ts"],"names":[],"mappings":"AACA,OAAO,uBAAgD,6CAAiD;AAKxG,OAAO,EAAC,eAAe,EAAC,0BAAqC;AAC7D,OAAO,EAAC,MAAM,EAAC,yBAA6B;AAK5C,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,EACzC,IAAI,EAAE,CAAC,EACP,SAAS,GAAE,uBAAuB,GAAG,MAAM,GAAG,IAAW,EACzD,SAAS,GAAE,OAAe,GACzB,eAAe,CAAC,CAAC,CAAC,CA2CpB;AAGD,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,CA4DrF"}

package/dist/core/proxy/Proxy.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rhineProxy = rhineProxy;
+exports.rhineProxyNative = rhineProxyNative;
+const yjs_1 = require("yjs");
+const WebsocketRhineConnector_1 = __importStar(require("../connector/WebsocketRhineConnector"));
+const RhineVar_1 = __importStar(require("./RhineVar"));
+const DataUtils_1 = require("../utils/DataUtils");
+const Logger_1 = require("../utils/Logger");
+const ConvertProperty_1 = require("../utils/ConvertProperty");
+const NativeUtils_1 = require("../native/NativeUtils");
+const DirectPackage_1 = __importStar(require("./DirectPackage"));
+function rhineProxy(data, connector = null, overwrite = false) {
+    let target = (0, NativeUtils_1.jsonToNative)(data);
+    if (connector) {
+        if (typeof connector === 'string') {
+            if (!connector.startsWith('ws://') && !connector.startsWith('wss://')) {
+                connector = 'wss://' + connector;
+            }
+            connector = (0, WebsocketRhineConnector_1.websocketRhineConnect)(connector);
+        }
+        target = connector.bind(target, overwrite);
+    }
+    connector = connector;
+    const object = rhineProxyNative(target);
+    object.connector = connector;
+    if (connector && !connector.synced) {
+        connector.addSyncedListener((synced) => {
+            if (!synced)
+                return;
+            let syncedValue = target.clone();
+            if (!overwrite && connector.yBaseMap.has(WebsocketRhineConnector_1.default.STATE_KEY)) {
+                syncedValue = connector.yBaseMap.get(WebsocketRhineConnector_1.default.STATE_KEY);
+                object.native.forEach((value, key) => {
+                    Reflect.deleteProperty(object, key);
+                });
+                object.unobserve();
+                object.native = syncedValue;
+                object.observe();
+                (0, Logger_1.log)('Proxy.synced: Update synced native');
+                syncedValue.forEach((value, key) => {
+                    if ((0, NativeUtils_1.isYMapOrYArray)(value)) {
+                        Reflect.set(object, key, (0, DirectPackage_1.directPackage)(rhineProxyNative(value)));
+                    }
+                });
+            }
+            else {
+                connector.yBaseMap.set(WebsocketRhineConnector_1.default.STATE_KEY, syncedValue);
+            }
+        });
+    }
+    return object;
+}
+function rhineProxyNative(target) {
+    // log('rhineProxyNative', target)
+    const object = new RhineVar_1.default(target);
+    object.native.forEach((value, keyString) => {
+        let key = keyString;
+        if ((0, NativeUtils_1.isYMapOrYArray)(value)) {
+            Reflect.set(object, key, rhineProxyNative(value));
+        }
+    });
+    const handler = {
+        get(proxy, p, receiver) {
+            if (RhineVar_1.RHINE_VAR_KEYS.has(p))
+                return Reflect.get(object, p, receiver);
+            (0, Logger_1.log)('Proxy.handler.get:', p, '\n', object, receiver);
+            if (p in object)
+                return Reflect.get(object, p, receiver);
+            let result = (0, NativeUtils_1.nativeGet)(object.native, p);
+            if (result)
+                return result;
+            if (object.native instanceof yjs_1.Array) {
+                if (typeof p === 'string') {
+                    const f = (0, ConvertProperty_1.convertArrayProperty)(object.native, p, object);
+                    if (f)
+                        return f;
+                }
+            }
+            return undefined;
+        },
+        set(proxy, p, value, receiver) {
+            if (RhineVar_1.RHINE_VAR_KEYS.has(p))
+                return Reflect.set(object, p, value, receiver);
+            if (value instanceof DirectPackage_1.default)
+                return Reflect.set(object, p, value.data, receiver);
+            (0, Logger_1.log)('Proxy.handler.set:', p, 'to', value, '\n', object, receiver);
+            value = (0, DataUtils_1.ensureRhineVar)(value);
+            let result = false;
+            if ((0, DataUtils_1.isObjectOrArray)(value)) {
+                result = (0, NativeUtils_1.nativeSet)(object.native, p, value.native);
+            }
+            else {
+                result = (0, NativeUtils_1.nativeSet)(object.native, p, value);
+            }
+            if (!result)
+                console.error('Failed to set value');
+            return result;
+        },
+        deleteProperty(proxy, p) {
+            if (RhineVar_1.RHINE_VAR_KEYS.has(p))
+                return false;
+            (0, Logger_1.log)('Proxy.handler.deleteProperty:', p);
+            let result = (0, NativeUtils_1.nativeDelete)(object.native, p);
+            if (!result)
+                console.error('Failed to delete value');
+            return result;
+        }
+    };
+    object.observe();
+    return new Proxy(object, handler);
+}

package/dist/core/proxy/RhineVar.d.ts

@@ -0,0 +1,25 @@
+import { Transaction, YArrayEvent, YMapEvent } from "yjs";
+import WebsocketRhineConnector from "../connector/WebsocketRhineConnector";
+import { Native } from "../native/Native";
+import { ChangeType } from "../event/ChangeType";
+import { Callback } from "../event/Callback";
+export default class RhineVar {
+    native: Native;
+    constructor(native: Native);
+    connector: WebsocketRhineConnector | null;
+    json(): any[] | {
+        [x: string]: any;
+    };
+    private listeners;
+    subscribe(callback: Callback): () => void;
+    unsubscribe(callback: Callback): void;
+    private keyListeners;
+    subscribeKey(key: string, callback: Callback): () => void;
+    unsubscribeKey(callback: Callback): void;
+    emit(value: any, key: string, oldValue: any, type: ChangeType, nativeEvent: YMapEvent<any> | YArrayEvent<any>, nativeTransaction: Transaction): void;
+    observer: (event: YMapEvent<any> | YArrayEvent<any>, transaction: Transaction) => void;
+    observe(): void;
+    unobserve(): void;
+}
+export declare const RHINE_VAR_KEYS: Set<string | symbol>;
+//# sourceMappingURL=RhineVar.d.ts.map

package/dist/core/proxy/RhineVar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RhineVar.d.ts","sourceRoot":"","sources":["../../../src/core/proxy/RhineVar.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,WAAW,EAAE,WAAW,EAAE,SAAS,EAAC,MAAM,KAAK,CAAC;AAEtF,OAAO,uBAAuB,6CAAiD;AAG/E,OAAO,EAAC,MAAM,EAAC,yBAA6B;AAC5C,OAAO,EAAC,UAAU,EAAC,4BAAgC;AACnD,OAAO,EAAC,QAAQ,EAAC,0BAA8B;AAG/C,MAAM,CAAC,OAAO,OAAO,QAAQ;IAGlB,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;IAGvB,SAAS,EAAE,uBAAuB,GAAG,IAAI,CAAO;IAEzC,IAAI;;;IAIX,OAAO,CAAC,SAAS,CAAiB;IAClC,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAIzC,WAAW,CAAC,QAAQ,EAAE,QAAQ;IAI9B,OAAO,CAAC,YAAY,CAAqC;IACzD,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,MAAM,IAAI;IAOzD,cAAc,CAAC,QAAQ,EAAE,QAAQ;IAMjC,IAAI,CAAC,KAAK,EAAE,GAAG,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,EAAE,iBAAiB,EAAE,WAAW;IAO7I,QAAQ,UAAW,SAAS,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,eAAe,WAAW,UAAO;IAGrF,OAAO;IA+BP,SAAS;CAMV;AAED,eAAO,MAAM,cAAc,sBAczB,CAAA"}

package/dist/core/proxy/RhineVar.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RHINE_VAR_KEYS = void 0;
+const yjs_1 = require("yjs");
+const Proxy_1 = require("./Proxy");
+const Logger_1 = require("../utils/Logger");
+const DataUtils_1 = require("../utils/DataUtils");
+const ChangeType_1 = require("../event/ChangeType");
+class RhineVar {
+    constructor(native) {
+        this.native = native;
+        this.connector = null;
+        this.listeners = [];
+        this.keyListeners = new Map();
+        this.observer = (event, transaction) => { };
+    }
+    json() {
+        return this.native.toJSON();
+    }
+    subscribe(callback) {
+        this.listeners.push(callback);
+        return () => this.unsubscribe(callback);
+    }
+    unsubscribe(callback) {
+        this.listeners = this.listeners.filter(listener => listener !== callback);
+    }
+    subscribeKey(key, callback) {
+        if (!this.keyListeners.has(key)) {
+            this.keyListeners.set(key, []);
+        }
+        this.keyListeners.get(key).push(callback);
+        return () => this.unsubscribeKey(callback);
+    }
+    unsubscribeKey(callback) {
+        this.keyListeners.forEach((listeners, key) => {
+            this.keyListeners.set(key, listeners.filter(listener => listener !== callback));
+        });
+    }
+    emit(value, key, oldValue, type, nativeEvent, nativeTransaction) {
+        this.listeners.forEach(listener => listener(value, key, oldValue, type, nativeEvent, nativeTransaction));
+        if (this.keyListeners.has(key)) {
+            this.keyListeners.get(key).forEach(listener => listener(value, key, oldValue, type, nativeEvent, nativeTransaction));
+        }
+    }
+    // 开始观察当前Native的内容变化
+    observe() {
+        const target = this.native;
+        if (target instanceof yjs_1.Map) {
+            this.observer = (event, transaction) => {
+                event.changes.keys.forEach(({ action, oldValue }, key) => {
+                    (0, Logger_1.log)(`Proxy.event: Map ${action} ${key}: ${oldValue} -> ${target.get(key)}`);
+                    let value = target.get(key);
+                    if (action === 'add' || action === 'update') {
+                        if ((0, DataUtils_1.isObjectOrArray)(value)) {
+                            Reflect.set(this, key, (0, Proxy_1.rhineProxyNative)(value));
+                        }
+                    }
+                    else if (action === 'delete') {
+                        Reflect.deleteProperty(this, key);
+                    }
+                    this.emit(target.get(key), key, oldValue, action, event, transaction);
+                });
+            };
+        }
+        else if (target instanceof yjs_1.Array) {
+            this.observer = (event, transaction) => {
+                (0, Logger_1.log)(`Proxy.event: Array changed.`, event, transaction);
+                const { added, deleted, delta } = event.changes;
+                this.emit(delta, '', undefined, ChangeType_1.ChangeType.Update, event, transaction);
+            };
+        }
+        if (this.observer) {
+            target.observe(this.observer);
+        }
+    }
+    // 当存在观察者时 结束观察当前native的内容变化
+    unobserve() {
+        if (this.observer) {
+            this.native.unobserve(this.observer);
+        }
+    }
+}
+exports.default = RhineVar;
+exports.RHINE_VAR_KEYS = new Set([
+    'native',
+    'json',
+    'listeners',
+    'subscribe',
+    'unsubscribe',
+    'keyListeners',
+    'subscribeKey',
+    'unsubscribeKey',
+    'emit',
+    'observer',
+    'observe',
+    'unobserve',
+    'connector',
+]);

package/dist/core/utils/ConvertProperty.d.ts

@@ -0,0 +1,4 @@
+import { Array as YArray } from "yjs";
+import RhineVar from "../proxy/RhineVar";
+export declare function convertArrayProperty<T>(target: YArray<T>, name: string, object: RhineVar): number | ((item: T | RhineVar) => void) | ((...items: T[]) => number) | ((start: number, deleteCount: number, ...items: T[]) => T[]) | ((callback: (value: T, index: number, arr: YArray<any>) => void) => void) | ((item: T) => boolean) | undefined;
+//# sourceMappingURL=ConvertProperty.d.ts.map

package/dist/core/utils/ConvertProperty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConvertProperty.d.ts","sourceRoot":"","sources":["../../../src/core/utils/ConvertProperty.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,KAAK,IAAI,MAAM,EAAC,MAAM,KAAK,CAAC;AACpC,OAAO,QAAQ,0BAA8B;AAG7C,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,oBAIvE,CAAC,GAAG,QAAQ,yBAsBR,CAAC,EAAE,wBASN,MAAM,eAAe,MAAM,YAAY,CAAC,EAAE,wBASvC,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,qBAevD,CAAC,0BAOlB"}

package/dist/core/utils/ConvertProperty.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertArrayProperty = convertArrayProperty;
+const RhineVar_1 = __importDefault(require("../proxy/RhineVar"));
+const DataUtils_1 = require("./DataUtils");
+function convertArrayProperty(target, name, object) {
+    if (name === 'length') {
+        return target.length;
+    }
+    if (name === 'push') {
+        return (item) => {
+            item = (0, DataUtils_1.ensureRhineVar)(item);
+            if (item instanceof RhineVar_1.default) {
+                target.push([item.native]);
+                Reflect.set(object, target.length - 1, item);
+            }
+            else {
+                target.push([item]);
+            }
+        };
+    }
+    else if (name === 'pop') {
+        return () => {
+            let item = target.get(target.length - 1);
+            target.delete(target.length - 1);
+            return item;
+        };
+    }
+    else if (name === 'shift') {
+        return () => {
+            let item = target.get(0);
+            target.delete(0);
+            return item;
+        };
+    }
+    else if (name === 'unshift') {
+        return (...items) => {
+            target.unshift(items);
+            return target.length;
+        };
+    }
+    else if (name === 'slice') {
+        return (start, end) => {
+            return target.slice(start, end);
+        };
+    }
+    else if (name === 'splice') {
+        return (start, deleteCount, ...items) => {
+            const removed = target.slice(start, start + deleteCount);
+            target.delete(start, deleteCount);
+            if (items.length > 0) {
+                target.insert(start, items);
+            }
+            return removed;
+        };
+    }
+    else if (name === 'forEach') {
+        return (callback) => {
+            return target.forEach(callback);
+        };
+    }
+    else if (name === 'map') {
+        return (callback) => {
+            return target.map(callback);
+        };
+    }
+    else if (name === 'indexOf') {
+        return (item) => {
+            for (let i = 0; i < target.length; i++) {
+                if (target.get(i) === item)
+                    return i;
+            }
+            return -1;
+        };
+    }
+    else if (name === 'includes') {
+        return (item) => {
+            for (let i = 0; i < target.length; i++) {
+                if (target.get(i) === item)
+                    return true;
+            }
+            return false;
+        };
+    }
+}

package/dist/core/utils/DataUtils.d.ts

@@ -0,0 +1,6 @@
+import { ProxiedRhineVar } from "../proxy/ProxiedRhineVar";
+export declare function isObject(value: any): boolean;
+export declare function isArray(value: any): value is any[];
+export declare function isObjectOrArray(value: any): boolean;
+export declare function ensureRhineVar<T>(value: T | ProxiedRhineVar<T>): ProxiedRhineVar<T> | any;
+//# sourceMappingURL=DataUtils.d.ts.map

package/dist/core/utils/DataUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataUtils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/DataUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,iCAAqC;AAK7D,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,WAElC;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,kBAEjC;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,WAEzC;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,GAAG,CAUzF"}

package/dist/core/utils/DataUtils.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.isArray = isArray;
+exports.isObjectOrArray = isObjectOrArray;
+exports.ensureRhineVar = ensureRhineVar;
+const NativeUtils_1 = require("../native/NativeUtils");
+const RhineVar_1 = __importDefault(require("../proxy/RhineVar"));
+const Proxy_1 = require("../proxy/Proxy");
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function isObjectOrArray(value) {
+    return value !== null && typeof value === 'object';
+}
+function ensureRhineVar(value) {
+    if ((0, NativeUtils_1.isYMapOrYArray)(value)) {
+        return (0, Proxy_1.rhineProxyNative)(value);
+    }
+    if (isObjectOrArray(value)) {
+        if (!(value instanceof RhineVar_1.default)) {
+            return (0, Proxy_1.rhineProxy)(value);
+        }
+    }
+    return value;
+}

package/dist/core/utils/Logger.d.ts

@@ -0,0 +1,2 @@
+export declare function log(...items: any[]): void;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/core/utils/Logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.d.ts","sourceRoot":"","sources":["../../../src/core/utils/Logger.ts"],"names":[],"mappings":"AAGA,wBAAgB,GAAG,CAAC,GAAG,KAAK,EAAE,GAAG,EAAE,QAIlC"}

package/dist/core/utils/Logger.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+const ENABLE_LOG = true;
+function log(...items) {
+    if (ENABLE_LOG) {
+        console.log('%cRhineVar', 'color: #b6ff00', ...items);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { rhineProxy, rhineProxyNative } from "./core/proxy/Proxy";
+import RhineVar from "./core/proxy/RhineVar";
+import { ProxiedRhineVar, RecursiveCrossRhineVar } from "./core/proxy/ProxiedRhineVar";
+import DirectPackage from "./core/proxy/DirectPackage";
+import WebsocketRhineConnector from "./core/connector/WebsocketRhineConnector";
+import useRhine from "./react/hooks/useRhine";
+import useSynced from "./react/hooks/useSynced";
+export { WebsocketRhineConnector, rhineProxy, rhineProxyNative, RhineVar, ProxiedRhineVar, RecursiveCrossRhineVar, DirectPackage, useRhine, useSynced, };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,gBAAgB,EAAC,2BAA2B;AAChE,OAAO,QAAQ,8BAA8B;AAC7C,OAAO,EAAC,eAAe,EAAE,sBAAsB,EAAC,qCAAqC;AACrF,OAAO,aAAa,mCAAmC;AACvD,OAAO,uBAAuB,iDAAiD;AAC/E,OAAO,QAAQ,+BAA8B;AAC7C,OAAO,SAAS,gCAA+B;AAE/C,OAAO,EACL,uBAAuB,EACvB,UAAU,EACV,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,sBAAsB,EACtB,aAAa,EACb,QAAQ,EACR,SAAS,GACV,CAAA"}

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSynced = exports.useRhine = exports.DirectPackage = exports.RhineVar = exports.rhineProxyNative = exports.rhineProxy = exports.WebsocketRhineConnector = void 0;
+const Proxy_1 = require("./core/proxy/Proxy");
+Object.defineProperty(exports, "rhineProxy", { enumerable: true, get: function () { return Proxy_1.rhineProxy; } });
+Object.defineProperty(exports, "rhineProxyNative", { enumerable: true, get: function () { return Proxy_1.rhineProxyNative; } });
+const RhineVar_1 = __importDefault(require("./core/proxy/RhineVar"));
+exports.RhineVar = RhineVar_1.default;
+const DirectPackage_1 = __importDefault(require("./core/proxy/DirectPackage"));
+exports.DirectPackage = DirectPackage_1.default;
+const WebsocketRhineConnector_1 = __importDefault(require("./core/connector/WebsocketRhineConnector"));
+exports.WebsocketRhineConnector = WebsocketRhineConnector_1.default;
+const useRhine_1 = __importDefault(require("./react/hooks/useRhine"));
+exports.useRhine = useRhine_1.default;
+const useSynced_1 = __importDefault(require("./react/hooks/useSynced"));
+exports.useSynced = useSynced_1.default;

package/dist/react/hooks/useRhine.d.ts

@@ -0,0 +1,3 @@
+import { ProxiedRhineVar } from "../../core/proxy/ProxiedRhineVar";
+export default function useRhine<T extends object>(proxy: ProxiedRhineVar<T>): T;
+//# sourceMappingURL=useRhine.d.ts.map

package/dist/react/hooks/useRhine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRhine.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useRhine.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,yCAAqC;AAE7D,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC,KAc3E"}

package/dist/react/hooks/useRhine.js

@@ -0,0 +1,18 @@
+"use strict";
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = useRhine;
+const react_1 = require("react");
+function useRhine(proxy) {
+    const [state, setState] = (0, react_1.useState)(proxy.json());
+    (0, react_1.useEffect)(() => {
+        var _a;
+        proxy.subscribe(() => {
+            setState(proxy.json());
+        });
+        (_a = proxy.connector) === null || _a === void 0 ? void 0 : _a.addSyncedListener(() => {
+            setState(proxy.json());
+        });
+    }, []);
+    return state;
+}

package/dist/react/hooks/useSynced.d.ts

@@ -0,0 +1,4 @@
+import WebsocketRhineConnector from "../../core/connector/WebsocketRhineConnector";
+import { ProxiedRhineVar } from "../../core/proxy/ProxiedRhineVar";
+export default function useSynced(target?: WebsocketRhineConnector | ProxiedRhineVar<any>): boolean | undefined;
+//# sourceMappingURL=useSynced.d.ts.map

package/dist/react/hooks/useSynced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSynced.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/useSynced.ts"],"names":[],"mappings":"AAAA,OAAO,uBAAuB,qDAAiD;AAE/E,OAAO,EAAC,eAAe,EAAC,yCAAqC;AAE7D,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,MAAM,CAAC,EAAE,uBAAuB,GAAG,eAAe,CAAC,GAAG,CAAC,uBA0BxF"}

package/dist/react/hooks/useSynced.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = useSynced;
+const WebsocketRhineConnector_1 = __importDefault(require("../../core/connector/WebsocketRhineConnector"));
+const react_1 = require("react");
+function useSynced(target) {
+    let connector = null;
+    if (target) {
+        if (target instanceof WebsocketRhineConnector_1.default) {
+            connector = target;
+        }
+        else {
+            connector = target.connector;
+        }
+    }
+    const [synced, setSynced] = (0, react_1.useState)(connector === null || connector === void 0 ? void 0 : connector.synced);
+    (0, react_1.useEffect)(() => {
+        let listener = null;
+        if (connector) {
+            listener = (synced) => setSynced(synced);
+            connector.addSyncedListener(listener);
+        }
+        return () => {
+            if (listener && connector) {
+                connector.removeSyncedListener(listener);
+            }
+        };
+    }, []);
+    return synced;
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "rhine-var",
+  "version": "0.1.0",
+  "description": "Variables that support multi-user collaboration and persistence, making collaboration and variable operations as simple as possible, with strict and well-defined type hints.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepare": "ts-patch install -s",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@testing-library/jest-dom": "^6.5.0",
+    "@testing-library/react": "^16.0.1",
+    "@testing-library/react-hooks": "^8.0.1",
+    "@types/jest": "^29.5.12",
+    "@types/puppeteer": "^7.0.4",
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "jest": "^29.7.0",
+    "jest-puppeteer": "^10.1.1",
+    "puppeteer": "^23.3.0",
+    "ts-jest": "^29.2.5",
+    "ts-node": "^10.9.2",
+    "ts-patch": "^3.2.1",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "react": "^18.3.1",
+    "typescript-transform-paths": "^3.5.0",
+    "y-websocket": "^2.0.4",
+    "yjs": "^13.6.18"
+  }
+}