@kokimoki/app 3.1.3 → 3.1.4

package/dist/kokimoki-store.js

@@ -1,117 +0,0 @@
-import * as Y from "yjs";
-import { snapshot, proxy, subscribe } from "valtio/vanilla";
-import { bind as yjsBind } from "valtio-yjs";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-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/kokimoki-transaction.d.ts

@@ -1,18 +0,0 @@
-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/kokimoki-transaction.js

@@ -1,143 +0,0 @@
-import * as Y from "yjs";
-import { proxy as yjsProxy } from "valtio/vanilla";
-import { bind as yjsBind } from "valtio-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/message-queue.d.ts

@@ -1,8 +0,0 @@
-import { SyncedStore } from "./synced-store";
-export declare class MessageQueue<T> extends SyncedStore<{
-  messages: T[];
-}> {
-  name: string;
-  constructor(name: string);
-  push(message: T): Promise<Uint8Array>;
-}

package/dist/message-queue.js

@@ -1,19 +0,0 @@
-import EventEmitter from "events";
-import { SyncedStore } from "./synced-store";
-import Y from "yjs";
-export class MessageQueue extends SyncedStore {
-  name;
-  constructor(name) {
-    super({ messages: [] });
-    this.name = name;
-  }
-  async push(message) {
-    // Construct Y update to push the message to the queue
-    const id = crypto.randomUUID();
-    const ydoc = new Y.Doc();
-    const map = ydoc.getMap("messages");
-    map.set(id, message);
-    const update = Y.encodeStateAsUpdate(ydoc);
-    return update;
-  }
-}

package/dist/room-subscription-mode.d.ts

@@ -1,5 +0,0 @@
-export declare enum RoomSubscriptionMode {
-    Read = "r",
-    Write = "w",
-    ReadWrite = "b"
-}

package/dist/room-subscription-mode.js

@@ -1,6 +0,0 @@
-export var RoomSubscriptionMode;
-(function (RoomSubscriptionMode) {
-    RoomSubscriptionMode["Read"] = "r";
-    RoomSubscriptionMode["Write"] = "w";
-    RoomSubscriptionMode["ReadWrite"] = "b";
-})(RoomSubscriptionMode || (RoomSubscriptionMode = {}));

package/dist/room-subscription.d.ts

@@ -1,15 +0,0 @@
-import type { KokimokiStore } from "./kokimoki-store";
-import type { KokimokiClient } from "./kokimoki-client";
-export declare class RoomSubscription {
-    private kmClient;
-    readonly store: KokimokiStore<any>;
-    private _joined;
-    private _roomHash?;
-    private _onDisconnect;
-    constructor(kmClient: KokimokiClient, store: KokimokiStore<any>);
-    get roomName(): string;
-    get roomHash(): number;
-    get joined(): boolean;
-    applyInitialResponse(roomHash: number, initialUpdate?: Uint8Array): Promise<void>;
-    close(): void;
-}

package/dist/room-subscription.js

@@ -1,52 +0,0 @@
-import * as Y from "yjs";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-export class RoomSubscription {
-    kmClient;
-    store;
-    _joined = false;
-    _roomHash;
-    _onDisconnect = () => {
-        this._joined = false;
-    };
-    constructor(kmClient, store) {
-        this.kmClient = kmClient;
-        this.store = store;
-        kmClient.on("disconnected", this._onDisconnect);
-    }
-    get roomName() {
-        return this.store.roomName;
-    }
-    get roomHash() {
-        if (!this._roomHash) {
-            throw new Error("Room not joined");
-        }
-        return this._roomHash;
-    }
-    get joined() {
-        return this._joined;
-    }
-    async applyInitialResponse(roomHash, initialUpdate) {
-        this._roomHash = roomHash;
-        // Apply initial state
-        if (initialUpdate) {
-            Y.applyUpdate(this.store.doc, initialUpdate, this);
-        }
-        // Set defaults if doc is empty after sync (only possible in ReadWrite mode)
-        if (this.store.mode === RoomSubscriptionMode.ReadWrite) {
-            await this.kmClient.transact([this.store], ([state]) => {
-                if (!("_connections" in state)) {
-                    state._connections = {};
-                }
-                for (const key in this.store.defaultValue) {
-                    if (!state.hasOwnProperty(key)) {
-                        state[key] = this.store.defaultValue[key];
-                    }
-                }
-            });
-        }
-        this._joined = true;
-    }
-    close() {
-        this.kmClient.off("disconnected", this._onDisconnect);
-    }
-}

package/dist/synced-schema.d.ts

@@ -1,74 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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);
-}