@kokimoki/app 1.17.0 → 2.0.1

package/dist/stores/kokimoki-store.js

@@ -0,0 +1,117 @@
+import { bind as yjsBind } from "valtio-yjs";
+import { proxy, snapshot, subscribe } from "valtio/vanilla";
+import * as Y from "yjs";
+import { RoomSubscriptionMode } from "../core";
+export class KokimokiStore {
+    roomName;
+    defaultValue;
+    mode;
+    doc;
+    proxy;
+    docRoot;
+    connections;
+    _unsubscribeConnectionsHandler = () => { };
+    constructor(roomName, defaultValue, mode = RoomSubscriptionMode.ReadWrite) {
+        this.roomName = roomName;
+        this.defaultValue = defaultValue;
+        this.mode = mode;
+        // "_connections" is a reserved key for tracking connections
+        if ("_connections" in defaultValue) {
+            throw new Error(`"_connections" is a reserved key in KokimokiStore`);
+        }
+        // Construct Y doc
+        this.doc = new Y.Doc();
+        this.docRoot = this.doc.getMap("root");
+        // Construct proxy object
+        this.proxy = proxy();
+        // @ts-ignore
+        yjsBind(this.proxy, this.docRoot);
+        // Construct connections proxy
+        this.connections = proxy({
+            connectionIds: new Set(),
+            clientIds: new Set(),
+        });
+    }
+    get() {
+        return snapshot(this.proxy);
+    }
+    subscribe(set) {
+        const handler = () => set(this.get());
+        this.doc.on("update", handler);
+        set(this.get());
+        return () => this.doc.off("update", handler);
+    }
+    async onJoin(client) {
+        // Update connections whenever _connections changes
+        let prevConnectionIds = new Set();
+        let prevClientIds = new Set();
+        this._unsubscribeConnectionsHandler = subscribe(this.proxy, () => {
+            // @ts-ignore
+            const newConnectionIds = new Set(
+            // @ts-ignore
+            Object.keys(this.proxy._connections || {}));
+            // Update only if there are changes
+            let connectionIdsChanged = false;
+            if (newConnectionIds.size !== prevConnectionIds.size) {
+                connectionIdsChanged = true;
+            }
+            if (!connectionIdsChanged) {
+                for (const id of newConnectionIds) {
+                    if (!prevConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!connectionIdsChanged) {
+                for (const id of prevConnectionIds) {
+                    if (!newConnectionIds.has(id)) {
+                        connectionIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (connectionIdsChanged) {
+                this.connections.connectionIds = newConnectionIds;
+                prevConnectionIds = new Set(newConnectionIds);
+            }
+            // @ts-ignore
+            const newClientIds = new Set(
+            // @ts-ignore
+            Object.values(this.proxy._connections || {}));
+            // Update only if there are changes
+            let clientIdsChanged = false;
+            if (newClientIds.size !== prevClientIds.size) {
+                clientIdsChanged = true;
+            }
+            if (!clientIdsChanged) {
+                for (const id of newClientIds) {
+                    if (!prevClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (!clientIdsChanged) {
+                for (const id of prevClientIds) {
+                    if (!newClientIds.has(id)) {
+                        clientIdsChanged = true;
+                        break;
+                    }
+                }
+            }
+            if (clientIdsChanged) {
+                this.connections.clientIds = newClientIds;
+                prevClientIds = new Set(newClientIds);
+            }
+        });
+        // Add client to _connections map
+        await client.transact([this], ([state]) => {
+            state._connections[client.connectionId] = client.id;
+        });
+    }
+    async onBeforeLeave(_client) { }
+    async onLeave(_client) {
+        this._unsubscribeConnectionsHandler();
+    }
+}

package/dist/stores/kokimoki-transaction.d.ts

@@ -0,0 +1,18 @@
+import { KokimokiStore } from "./kokimoki-store";
+export declare class KokimokiTransaction<T extends object[]> {
+    private _updates;
+    private _consumeMessagesInRooms;
+    private _proxies;
+    private _unbindProxies;
+    constructor(stores: {
+        [K in keyof T]: KokimokiStore<T[K]>;
+    });
+    getProxies(): T;
+    getUpdates(): Promise<{
+        updates: {
+            roomName: string;
+            update: Uint8Array;
+        }[];
+        consumedMessages: Set<string>;
+    }>;
+}

package/dist/stores/kokimoki-transaction.js

@@ -0,0 +1,143 @@
+import { bind as yjsBind } from "valtio-yjs";
+import { proxy as yjsProxy } from "valtio/vanilla";
+import * as Y from "yjs";
+export class KokimokiTransaction {
+    // private _clones = new Map<
+    //   string,
+    //   { docClone: Y.Doc; proxyClone: any; unbindProxy: () => void }
+    // >();
+    _updates = new Map();
+    _consumeMessagesInRooms = new Set();
+    // private _queueMessageCounter = 0;
+    _proxies = [];
+    _unbindProxies = [];
+    constructor(stores) {
+        // Create a proxy for each store
+        for (const store of stores) {
+            // Clone initial state
+            const docClone = new Y.Doc();
+            const docRoot = docClone.getMap("root");
+            Y.applyUpdate(docClone, Y.encodeStateAsUpdate(store.doc));
+            // Set up proxy
+            const proxyClone = yjsProxy();
+            const unbindProxy = yjsBind(proxyClone, docRoot);
+            this._proxies.push(proxyClone);
+            this._unbindProxies.push(unbindProxy);
+            // Listen for updates
+            docClone.on("update", (update) => {
+                if (this._updates.has(store.roomName)) {
+                    const prevUpdate = this._updates.get(store.roomName);
+                    const nextUpdate = Y.mergeUpdates([prevUpdate, update]);
+                    this._updates.set(store.roomName, nextUpdate);
+                }
+                else {
+                    this._updates.set(store.roomName, update);
+                }
+            });
+            // this._clones.set(store.roomName, { docClone, proxyClone, unbindProxy });
+        }
+    }
+    getProxies() {
+        // @ts-ignore
+        return this._proxies;
+    }
+    // private _parseTarget(target: any): {
+    //   roomName: string;
+    //   doc: Y.Doc;
+    //   obj: any;
+    //   key: string;
+    //   path: string[];
+    // } {
+    //   return target();
+    // }
+    // private _parsePath(obj: any, path: string[]) {
+    //   for (let i = 0; i < path.length - 1; i++) {
+    //     if (!(path[i] in obj)) {
+    //       obj[path[i]] = {};
+    //     }
+    //     obj = obj[path[i]];
+    //   }
+    //   return { obj, key: path[path.length - 1] };
+    // }
+    // private _getClone(roomName: string, doc: Y.Doc) {
+    //   if (!this._clones.has(roomName)) {
+    //     // Clone doc
+    //     const docClone = new Y.Doc();
+    //     const docRoot = docClone.getMap("root");
+    //     Y.applyUpdate(docClone, Y.encodeStateAsUpdate(doc));
+    //     // Set up proxy
+    //     const proxyClone = yjsProxy() as any;
+    //     const unbindProxy = yjsBind(proxyClone, docRoot);
+    //     // Listen for updates
+    //     docClone.on("update", (update) => {
+    //       if (this._updates.has(roomName)) {
+    //         const prevUpdate = this._updates.get(roomName)!;
+    //         const nextUpdate = Y.mergeUpdates([prevUpdate, update]);
+    //         this._updates.set(roomName, nextUpdate);
+    //       } else {
+    //         this._updates.set(roomName, update);
+    //       }
+    //     });
+    //     this._clones.set(roomName, { docClone, proxyClone, unbindProxy });
+    //   }
+    //   return this._clones.get(roomName)!;
+    // }
+    // get<T>(target: T): T {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   return obj[key];
+    // }
+    // set<T>(target: T, value: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   obj[key] = value;
+    // }
+    // delete<T>(target: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   delete obj[key];
+    // }
+    // push<T>(target: T[], value: T) {
+    //   const { roomName, doc, path } = this._parseTarget(target);
+    //   const { proxyClone } = this._getClone(roomName, doc);
+    //   const { obj, key } = this._parsePath(proxyClone, path);
+    //   if (!(key in obj)) {
+    //     obj[key] = [];
+    //   }
+    //   obj[key].push(value);
+    // }
+    // queueMessage<T>(queue: KokimokiQueue<S.Generic<T>>, payload: T) {
+    //   const messageId = `${this.kmClient.serverTimestamp()}/${this
+    //     ._queueMessageCounter++}/${Math.random().toString(36).slice(2)}`;
+    //   this.set(queue.root[messageId], payload);
+    //   return messageId;
+    // }
+    // consumeMessage<T>(queue: KokimokiQueue<S.Generic<T>>, messageId: string) {
+    //   if (!queue.proxy[messageId]) {
+    //     throw new Error(
+    //       `Message ${messageId} does not exist or has already been consumed`
+    //     );
+    //   }
+    //   this.delete(queue.root[messageId]);
+    //   this._consumeMessagesInRooms.add(queue.roomName);
+    // }
+    async getUpdates() {
+        // Wait for doc update handling to finish
+        return await new Promise((resolve) => setTimeout(() => {
+            // Clean up
+            for (const unbindProxy of this._unbindProxies) {
+                unbindProxy();
+            }
+            // Generates updates
+            const updates = Array.from(this._updates.entries()).map(([roomName, update]) => ({
+                roomName,
+                update,
+            }));
+            // Done
+            resolve({ updates, consumedMessages: this._consumeMessagesInRooms });
+        }));
+    }
+}

package/dist/synced-schema.d.ts

@@ -0,0 +1,74 @@
+export declare abstract class SyncedGeneric<T> {
+  abstract get defaultValue(): T;
+  abstract set defaultValue(value: T);
+}
+export declare class SyncedNumber extends SyncedGeneric<number> {
+  defaultValue: number;
+  constructor(defaultValue?: number);
+}
+declare function syncedNumber(defaultValue?: number): SyncedNumber;
+export declare class SyncedString extends SyncedGeneric<string> {
+  defaultValue: string;
+  constructor(defaultValue?: string);
+}
+declare function syncedString(defaultValue?: string): SyncedString;
+export declare class SyncedBoolean extends SyncedGeneric<boolean> {
+  defaultValue: boolean;
+  constructor(defaultValue?: boolean);
+}
+declare function syncedBoolean(defaultValue?: boolean): SyncedBoolean;
+export declare class SyncedObject<
+  Data extends Record<string, SyncedGeneric<unknown>>,
+> extends SyncedGeneric<{
+  [key in keyof Data]: Data[key]["defaultValue"];
+}> {
+  fields: Data;
+  constructor(fields: Data);
+  get defaultValue(): {
+    [key in keyof Data]: Data[key]["defaultValue"];
+  };
+  set defaultValue(value: {
+    [key in keyof Data]: Data[key]["defaultValue"];
+  });
+}
+declare function syncedObject<
+  Data extends Record<string, SyncedGeneric<unknown>>,
+>(schema: Data): SyncedObject<Data>;
+export declare class SyncedMap<T extends SyncedGeneric<unknown>> {
+  schema: T;
+  defaultValue: {
+    [key: string]: T["defaultValue"];
+  };
+  constructor(
+    schema: T,
+    defaultValue?: {
+      [key: string]: T["defaultValue"];
+    },
+  );
+}
+declare function syncedMap<T extends SyncedGeneric<unknown>>(
+  schema: T,
+  defaultValue?: {
+    [key: string]: T["defaultValue"];
+  },
+): SyncedMap<T>;
+export declare class SyncedArray<
+  T extends SyncedGeneric<unknown>,
+> extends SyncedGeneric<T["defaultValue"][]> {
+  schema: T;
+  defaultValue: T["defaultValue"][];
+  constructor(schema: T, defaultValue?: T["defaultValue"][]);
+}
+declare function syncedArray<T extends SyncedGeneric<unknown>>(
+  schema: T,
+  defaultValue?: T["defaultValue"][],
+): SyncedArray<T>;
+export declare const S: {
+  number: typeof syncedNumber;
+  string: typeof syncedString;
+  boolean: typeof syncedBoolean;
+  object: typeof syncedObject;
+  map: typeof syncedMap;
+  array: typeof syncedArray;
+};
+export {};

package/dist/synced-schema.js

@@ -0,0 +1,83 @@
+export class SyncedGeneric {}
+export class SyncedNumber extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = 0) {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+function syncedNumber(defaultValue = 0) {
+  return new SyncedNumber(defaultValue);
+}
+export class SyncedString extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = "") {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+function syncedString(defaultValue = "") {
+  return new SyncedString(defaultValue);
+}
+export class SyncedBoolean extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = false) {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+function syncedBoolean(defaultValue = false) {
+  return new SyncedBoolean(defaultValue);
+}
+export class SyncedObject extends SyncedGeneric {
+  fields;
+  constructor(fields) {
+    super();
+    this.fields = fields;
+  }
+  get defaultValue() {
+    return Object.entries(this.fields).reduce((acc, [key, field]) => {
+      acc[key] = field.defaultValue;
+      return acc;
+    }, {});
+  }
+  set defaultValue(value) {
+    for (const [key, field] of Object.entries(this.fields)) {
+      field.defaultValue = value[key];
+    }
+  }
+}
+function syncedObject(schema) {
+  return new SyncedObject(schema);
+}
+export class SyncedMap {
+  schema;
+  defaultValue;
+  constructor(schema, defaultValue = {}) {
+    this.schema = schema;
+    this.defaultValue = defaultValue;
+  }
+}
+function syncedMap(schema, defaultValue = {}) {
+  return new SyncedMap(schema, defaultValue);
+}
+export class SyncedArray extends SyncedGeneric {
+  schema;
+  defaultValue;
+  constructor(schema, defaultValue = []) {
+    super();
+    this.schema = schema;
+    this.defaultValue = defaultValue;
+  }
+}
+function syncedArray(schema, defaultValue = []) {
+  return new SyncedArray(schema, defaultValue);
+}
+export const S = {
+  number: syncedNumber,
+  string: syncedString,
+  boolean: syncedBoolean,
+  object: syncedObject,
+  map: syncedMap,
+  array: syncedArray,
+};

package/dist/synced-store.d.ts

@@ -0,0 +1,10 @@
+import type * as Y from "yjs";
+import type {
+  DocTypeDescription,
+  MappedTypeDescription,
+} from "@syncedstore/core/types/doc";
+export declare class SyncedStore<T extends DocTypeDescription> {
+  readonly data: MappedTypeDescription<T>;
+  readonly doc: Y.Doc;
+  constructor(initialState: T);
+}

package/dist/synced-store.js

@@ -0,0 +1,9 @@
+import { syncedStore, getYjsDoc } from "@syncedstore/core";
+export class SyncedStore {
+  data;
+  doc;
+  constructor(initialState) {
+    this.data = syncedStore(initialState);
+    this.doc = getYjsDoc(this.data);
+  }
+}

package/dist/synced-types.d.ts

@@ -0,0 +1,47 @@
+export declare abstract class SyncedGeneric<T> {
+  abstract get defaultValue(): T;
+  abstract set defaultValue(value: T);
+}
+export declare class SyncedNumber extends SyncedGeneric<number> {
+  defaultValue: number;
+  constructor(defaultValue?: number);
+}
+export declare function syncedNumber(defaultValue?: number): SyncedNumber;
+export declare class SyncedString extends SyncedGeneric<string> {
+  defaultValue: string;
+  constructor(defaultValue?: string);
+}
+export declare function syncedString(defaultValue?: string): SyncedString;
+export declare class SyncedBoolean extends SyncedGeneric<boolean> {
+  defaultValue: boolean;
+  constructor(defaultValue?: boolean);
+}
+export declare function syncedBoolean(defaultValue?: boolean): SyncedBoolean;
+export declare class SyncedMap<
+  Data extends Record<string, SyncedGeneric<unknown>>,
+> extends SyncedGeneric<{
+  [key in keyof Data]: Data[key]["defaultValue"];
+}> {
+  fields: Data;
+  constructor(fields: Data);
+  get defaultValue(): {
+    [key in keyof Data]: Data[key]["defaultValue"];
+  };
+  set defaultValue(value: {
+    [key in keyof Data]: Data[key]["defaultValue"];
+  });
+}
+export declare function syncedMap<
+  T extends Record<string, SyncedGeneric<unknown>>,
+>(schema: T): SyncedMap<T>;
+export declare class SyncedArray<
+  T extends SyncedGeneric<unknown>,
+> extends SyncedGeneric<T["defaultValue"][]> {
+  schema: T;
+  defaultValue: T["defaultValue"][];
+  constructor(schema: T, defaultValue?: T["defaultValue"][]);
+}
+export declare function syncedArray<T extends SyncedGeneric<unknown>>(
+  schema: T,
+  defaultValue?: T["defaultValue"][],
+): SyncedArray<T>;

package/dist/synced-types.js

@@ -0,0 +1,67 @@
+import * as Y from "yjs";
+import { proxy as yjsProxy } from "valtio";
+import { bind as yjsBind } from "valtio-yjs";
+export class SyncedGeneric {}
+export class SyncedNumber extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = 0) {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+export function syncedNumber(defaultValue = 0) {
+  return new SyncedNumber(defaultValue);
+}
+export class SyncedString extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = "") {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+export function syncedString(defaultValue = "") {
+  return new SyncedString(defaultValue);
+}
+export class SyncedBoolean extends SyncedGeneric {
+  defaultValue;
+  constructor(defaultValue = false) {
+    super();
+    this.defaultValue = defaultValue;
+  }
+}
+export function syncedBoolean(defaultValue = false) {
+  return new SyncedBoolean(defaultValue);
+}
+export class SyncedMap extends SyncedGeneric {
+  fields;
+  constructor(fields) {
+    super();
+    this.fields = fields;
+  }
+  get defaultValue() {
+    return Object.entries(this.fields).reduce((acc, [key, field]) => {
+      acc[key] = field.defaultValue;
+      return acc;
+    }, {});
+  }
+  set defaultValue(value) {
+    for (const [key, field] of Object.entries(this.fields)) {
+      field.defaultValue = value[key];
+    }
+  }
+}
+export function syncedMap(schema) {
+  return new SyncedMap(schema);
+}
+export class SyncedArray extends SyncedGeneric {
+  schema;
+  defaultValue;
+  constructor(schema, defaultValue = []) {
+    super();
+    this.schema = schema;
+    this.defaultValue = defaultValue;
+  }
+}
+export function syncedArray(schema, defaultValue = []) {
+  return new SyncedArray(schema, defaultValue);
+}

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./events";
+export * from "./upload";

package/dist/types/index.js

@@ -0,0 +1,3 @@
+export * from "./common";
+export * from "./events";
+export * from "./upload";

package/dist/utils/valtio.d.ts

@@ -0,0 +1,7 @@
+import "valtio";
+declare module "valtio" {
+    function useSnapshot<T extends object>(p: T): T;
+}
+export { proxy, ref, snapshot, subscribe, useSnapshot } from "valtio";
+export { derive, underive } from "derive-valtio";
+export { devtools, subscribeKey, useProxy, watch } from "valtio/utils";

package/dist/utils/valtio.js

@@ -0,0 +1,6 @@
+import "valtio";
+// Core Valtio exports
+export { proxy, ref, snapshot, subscribe, useSnapshot } from "valtio";
+// Valtio utilities
+export { derive, underive } from "derive-valtio";
+export { devtools, subscribeKey, useProxy, watch } from "valtio/utils";

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "1.17.0";
+export declare const KOKIMOKI_APP_VERSION = "2.0.1";

package/dist/version.js

@@ -1 +1,2 @@
-export const KOKIMOKI_APP_VERSION = "1.17.0";
+// Auto-generated file. Do not edit manually.
+export const KOKIMOKI_APP_VERSION = '2.0.1';

package/dist/ws-message-type copy.d.ts

@@ -0,0 +1,6 @@
+export declare enum WsMessageType {
+  SubscribeReq = 1,
+  SubscribeRes = 2,
+  Transaction = 3,
+  RoomUpdate = 4,
+}

package/dist/ws-message-type copy.js

@@ -0,0 +1,7 @@
+export var WsMessageType;
+(function (WsMessageType) {
+  WsMessageType[(WsMessageType["SubscribeReq"] = 1)] = "SubscribeReq";
+  WsMessageType[(WsMessageType["SubscribeRes"] = 2)] = "SubscribeRes";
+  WsMessageType[(WsMessageType["Transaction"] = 3)] = "Transaction";
+  WsMessageType[(WsMessageType["RoomUpdate"] = 4)] = "RoomUpdate";
+})(WsMessageType || (WsMessageType = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "1.17.0",
+  "version": "2.0.1",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -14,9 +14,9 @@
   },
   "scripts": {
     "test": "NODE_OPTIONS='--import tsx' mocha",
-    "prebuild": "node -p \"'export const KOKIMOKI_APP_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
+    "prebuild": "node scripts/generate-version.js",
     "build": "tsc",
-    "postbuild": "rollup --config",
+    "postbuild": "rollup --config && cp docs/instructions.md dist/llms.txt",
     "dev": "tsc -w",
     "docs": "typedoc src/index.ts",
     "rollup": "rollup --config"
@@ -44,6 +44,7 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
+    "derive-valtio": "^0.2.0",
     "events": "^3.3.0",
     "farmhash-modern": "^1.1.0",
     "typed-emitter": "^2.1.0",