@kokimoki/app 1.0.2 → 1.0.4

package/dist/kokimoki-client-refactored.d.ts

@@ -4,10 +4,10 @@ import type { Upload } from "./types/upload";
 import type { Paginated } from "./types/common";
 import { KokimokiTransaction } from "./kokimoki-transaction";
 import type { KokimokiStore } from "./kokimoki-store";
-import type { KokimokiSchema as S } from "./kokimoki-schema";
+import type { SyncedGeneric } from "./synced-schema";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
-declare const KokimokiClient_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
-export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient_base {
+declare const KokimokiClientRefactored_base: new () => TypedEmitter<KokimokiClientEventsRefactored>;
+export declare class KokimokiClientRefactored<ClientContextT = any> extends KokimokiClientRefactored_base {
     readonly host: string;
     readonly appId: string;
     readonly code: string;
@@ -19,14 +19,15 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     private _serverTimeOffset;
     private _clientContext?;
     private _ws?;
-    private _subscriptionsByName;
-    private _subscriptionsByHash;
-    private _subscribeReqPromises;
-    private _transactionPromises;
+    private _subscriptions;
+    private _stores;
+    private _reqPromises;
+    private _transactionResolves;
+    private _roomHashes;
+    private _roomHashToDoc;
     private _connected;
     private _connectPromise?;
     private _messageId;
-    private _reconnectTimeout;
     constructor(host: string, appId: string, code?: string);
     get id(): string;
     get token(): string;
@@ -61,7 +62,7 @@ export declare class KokimokiClient<ClientContextT = any> extends KokimokiClient
     }>;
     exposeScriptingContext(context: any): Promise<void>;
     private sendSubscriptionReq;
-    join<T extends S.Generic<unknown>>(store: KokimokiStore<T>, mode?: RoomSubscriptionMode): Promise<void>;
+    join<T extends SyncedGeneric<unknown>>(store: KokimokiStore<T>, mode?: RoomSubscriptionMode): Promise<void>;
     transact(handler: (t: KokimokiTransaction) => void): Promise<void>;
 }
 export {};

package/dist/kokimoki-client-refactored.js

@@ -6,8 +6,7 @@ import { WsMessageType } from "./ws-message-type";
 import { WsMessageWriter } from "./ws-message-writer";
 import { WsMessageReader } from "./ws-message-reader";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
-import { RoomSubscription } from "./room-subscription";
-export class KokimokiClient extends EventEmitter {
+export class KokimokiClientRefactored extends EventEmitter {
     host;
     appId;
     code;
@@ -19,14 +18,15 @@ export class KokimokiClient extends EventEmitter {
     _serverTimeOffset = 0;
     _clientContext;
     _ws;
-    _subscriptionsByName = new Map();
-    _subscriptionsByHash = new Map();
-    _subscribeReqPromises = new Map();
-    _transactionPromises = new Map();
+    _subscriptions = new Map();
+    _stores = new Map();
+    _reqPromises = new Map();
+    _transactionResolves = new Map();
+    _roomHashes = new Map();
+    _roomHashToDoc = new Map();
     _connected = false;
     _connectPromise;
     _messageId = 0;
-    _reconnectTimeout = 0;
     constructor(host, appId, code = "") {
         super();
         this.host = host;
@@ -82,17 +82,6 @@ export class KokimokiClient extends EventEmitter {
         }
         this._ws = new WebSocket(`${this._wsUrl}/apps/${this.appId}?clientVersion=${KOKIMOKI_APP_VERSION}`);
         this._ws.binaryType = "arraybuffer";
-        // Close previous connection in hot-reload scenarios
-        if (window) {
-            if (!window.__KOKIMOKI_WS__) {
-                window.__KOKIMOKI_WS__ = {};
-            }
-            if (this.appId in window.__KOKIMOKI_WS__) {
-                window.__KOKIMOKI_WS__[this.appId].close();
-            }
-            window.__KOKIMOKI_WS__[this.appId] = this._ws;
-        }
-        // Wait for connection
         this._connectPromise = new Promise((onInit) => {
             // Fetch the auth token
             let clientToken = localStorage.getItem("KM_TOKEN");
@@ -104,18 +93,16 @@ export class KokimokiClient extends EventEmitter {
                 this._connected = false;
                 this._connectPromise = undefined;
                 this._ws = undefined;
-                if (window && window.__KOKIMOKI_WS__) {
-                    delete window.__KOKIMOKI_WS__[this.appId];
-                }
                 // Clean up
-                this._subscribeReqPromises.clear();
-                this._transactionPromises.clear();
-                // Attempt to reconnect
-                console.log(`[Kokimoki] Connection lost, attempting to reconnect in ${this._reconnectTimeout} seconds...`);
-                setTimeout(async () => await this.connect(), this._reconnectTimeout * 1000);
-                this._reconnectTimeout = Math.min(3, this._reconnectTimeout + 1);
+                this._reqPromises.clear();
+                this._transactionResolves.clear();
+                this._roomHashes.clear();
+                this._roomHashToDoc.clear();
+                this._subscriptions.clear();
                 // Emit disconnected event
                 this.emit("disconnected");
+                // Attempt to reconnect
+                // setTimeout(async () => await this.connect(), 2000);
             };
             this.ws.onmessage = (e) => {
                 console.log(`Received WS message: ${e.data}`);
@@ -140,26 +127,6 @@ export class KokimokiClient extends EventEmitter {
             };
         });
         await this._connectPromise;
-        this._connected = true;
-        // Connection established
-        console.log(`[Kokimoki] Client id: ${this.id}`);
-        console.log(`[Kokimoki] Client context:`, this.clientContext);
-        // Restore subscriptions if reconnected
-        const roomNames = Array.from(this._subscriptionsByName.keys()).map((name) => `"${name}"`);
-        if (roomNames.length) {
-            console.log(`[Kokimoki] Restoring subscriptions: ${roomNames}`);
-        }
-        for (const subscription of this._subscriptionsByName.values()) {
-            try {
-                await this.join(subscription.store);
-            }
-            catch (err) {
-                console.error(`[Kokimoki] Failed to restore subscription for "${subscription.roomName}":`, err);
-            }
-        }
-        // Emit connected event
-        this._reconnectTimeout = 0;
-        this.emit("connected");
     }
     handleInitMessage(message) {
         localStorage.setItem("KM_TOKEN", message.clientToken);
@@ -171,6 +138,8 @@ export class KokimokiClient extends EventEmitter {
             Authorization: `Bearer ${this.token}`,
             "Content-Type": "application/json",
         });
+        this._connected = true;
+        this.emit("connected");
     }
     handleBinaryMessage(data) {
         const reader = new WsMessageReader(data);
@@ -190,15 +159,10 @@ export class KokimokiClient extends EventEmitter {
     handleErrorMessage(msg) {
         const reqId = msg.readInt32();
         const error = msg.readString();
-        const subscribeReqPromise = this._subscribeReqPromises.get(reqId);
-        const transactionPromise = this._transactionPromises.get(reqId);
-        if (subscribeReqPromise) {
-            this._subscribeReqPromises.delete(reqId);
-            subscribeReqPromise.reject(error);
-        }
-        else if (transactionPromise) {
-            this._transactionPromises.delete(reqId);
-            transactionPromise.reject(error);
+        const promise = this._reqPromises.get(reqId);
+        if (promise) {
+            this._reqPromises.delete(reqId);
+            promise.reject(error);
         }
         else {
             console.warn(`Received error for unknown request ${reqId}: ${error}`);
@@ -207,9 +171,9 @@ export class KokimokiClient extends EventEmitter {
     handleSubscribeResMessage(msg) {
         const reqId = msg.readInt32();
         const roomHash = msg.readUint32();
-        const promise = this._subscribeReqPromises.get(reqId);
+        const promise = this._reqPromises.get(reqId);
         if (promise) {
-            this._subscribeReqPromises.delete(reqId);
+            this._reqPromises.delete(reqId);
             // In Write mode, no initial state is sent
             if (!msg.end) {
                 promise.resolve(roomHash, msg.readUint8Array());
@@ -224,18 +188,18 @@ export class KokimokiClient extends EventEmitter {
         const roomHash = msg.readUint32();
         // Apply update if not in Write mode
         if (!msg.end) {
-            const subscription = this._subscriptionsByHash.get(roomHash);
-            if (subscription) {
-                Y.applyUpdate(subscription.store.doc, msg.readUint8Array(), this);
+            const doc = this._roomHashToDoc.get(roomHash);
+            if (doc) {
+                Y.applyUpdate(doc, msg.readUint8Array(), this);
             }
             else {
                 console.warn(`Received update for unknown room ${roomHash}`);
             }
         }
         // Check transaction resolves
-        for (const [transactionId, { resolve },] of this._transactionPromises.entries()) {
+        for (const [transactionId, resolve,] of this._transactionResolves.entries()) {
             if (appliedId >= transactionId) {
-                this._transactionPromises.delete(transactionId);
+                this._transactionResolves.delete(transactionId);
                 resolve();
             }
         }
@@ -331,7 +295,7 @@ export class KokimokiClient extends EventEmitter {
         // Set up sync resolver
         const reqId = ++this._messageId;
         return await new Promise((resolve, reject) => {
-            this._subscribeReqPromises.set(reqId, {
+            this._reqPromises.set(reqId, {
                 resolve: (roomHash, initialUpdate) => {
                     resolve({ roomHash, initialUpdate });
                 },
@@ -347,25 +311,42 @@ export class KokimokiClient extends EventEmitter {
         });
     }
     async join(store, mode = RoomSubscriptionMode.ReadWrite) {
-        let subscription = this._subscriptionsByName.get(store.roomName);
-        if (!subscription) {
-            subscription = new RoomSubscription(this, store, mode);
-            this._subscriptionsByName.set(store.roomName, subscription);
+        if (this._subscriptions.has(store.roomName)) {
+            throw new Error(`Already joined room "${store.roomName}"`);
         }
-        // Send subscription request if connected to server
-        if (!subscription.joined) {
+        this._subscriptions.set(store.roomName, mode);
+        // Send req
+        try {
             const res = await this.sendSubscriptionReq(store.roomName, mode);
-            this._subscriptionsByHash.set(res.roomHash, subscription);
-            await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
+            // Set room hash
+            this._roomHashes.set(store.roomName, res.roomHash);
+            this._roomHashToDoc.set(res.roomHash, store.doc);
+            this._stores.set(res.roomHash, store);
+            // Apply initial state
+            if (res.initialUpdate) {
+                Y.applyUpdate(store.doc, res.initialUpdate, this);
+            }
+            // Set defaults if doc is empty after sync (only possible in ReadWrite mode)
+            if (mode === RoomSubscriptionMode.ReadWrite) {
+                await this.transact((t) => {
+                    for (const key in store.defaultValue) {
+                        // @ts-ignore
+                        if (!store.proxy.hasOwnProperty(key)) {
+                            t.set(store.root[key], store.defaultValue[key]);
+                        }
+                    }
+                });
+            }
+        }
+        catch (err) {
+            this._subscriptions.delete(store.roomName);
+            throw err;
         }
     }
     async transact(handler) {
-        if (!this._connected) {
-            throw new Error("Client not connected");
-        }
         const transaction = new KokimokiTransaction(this);
         handler(transaction);
-        const { updates, consumedMessages } = await transaction.getUpdates();
+        const updates = await transaction.getUpdates();
         if (!updates.length) {
             return;
         }
@@ -376,28 +357,19 @@ export class KokimokiClient extends EventEmitter {
         // Update and write transaction ID
         const transactionId = ++this._messageId;
         writer.writeInt32(transactionId);
-        // Write room hashes where messages were consumed
-        writer.writeInt32(consumedMessages.size);
-        for (const roomName of consumedMessages) {
-            const subscription = this._subscriptionsByName.get(roomName);
-            if (!subscription) {
-                throw new Error(`Cannot consume message in "${roomName}" because it hasn't been joined`);
-            }
-            writer.writeUint32(subscription.roomHash);
-        }
         // Write updates
         for (const { roomName, update } of updates) {
-            const subscription = this._subscriptionsByName.get(roomName);
-            if (!subscription) {
+            const roomHash = this._roomHashes.get(roomName);
+            if (!roomHash) {
                 throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
             }
-            writer.writeUint32(subscription.roomHash);
+            writer.writeUint32(roomHash);
             writer.writeUint8Array(update);
         }
         const buffer = writer.getBuffer();
         // Wait for server to apply transaction
-        await new Promise((resolve, reject) => {
-            this._transactionPromises.set(transactionId, { resolve, reject });
+        await new Promise((resolve) => {
+            this._transactionResolves.set(transactionId, resolve);
             // Send update to server
             try {
                 this.ws.send(buffer);

package/dist/kokimoki-schema.d.ts

@@ -49,10 +49,30 @@ export declare namespace KokimokiSchema {
         constructor(schema: T, defaultValue?: T["defaultValue"][]);
     }
     function list<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"][]): List<T>;
+    /**
+     * Nullable
+     */
     class Nullable<T extends Generic<unknown>> extends Generic<T["defaultValue"] | null> {
         schema: T;
         defaultValue: T["defaultValue"] | null;
         constructor(schema: T, defaultValue: T["defaultValue"] | null);
     }
     function nullable<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | null): Nullable<T>;
+    class StringEnum<T extends readonly string[]> extends Generic<string> {
+        readonly options: T;
+        defaultValue: T[number];
+        constructor(options: T, defaultValue: T[number]);
+    }
+    function stringEnum<T extends readonly string[]>(options: T, defaultValue: T[number]): StringEnum<T>;
+    class StringConst<T extends string> extends Generic<string> {
+        readonly defaultValue: T;
+        constructor(defaultValue: T);
+    }
+    function stringConst<T extends string>(defaultValue: T): StringConst<T>;
+    class AnyOf<T extends readonly Generic<unknown>[]> extends Generic<T[number]["defaultValue"]> {
+        readonly schemas: T;
+        defaultValue: T[number]["defaultValue"];
+        constructor(schemas: T, defaultValue: T[number]["defaultValue"]);
+    }
+    function anyOf<T extends readonly Generic<unknown>[]>(schemas: T, defaultValue: T[number]["defaultValue"]): AnyOf<T>;
 }

package/dist/kokimoki-schema.js

@@ -89,6 +89,9 @@ export var KokimokiSchema;
         return new List(schema, defaultValue);
     }
     KokimokiSchema.list = list;
+    /**
+     * Nullable
+     */
     class Nullable extends Generic {
         schema;
         defaultValue;
@@ -103,4 +106,44 @@ export var KokimokiSchema;
         return new Nullable(schema, defaultValue);
     }
     KokimokiSchema.nullable = nullable;
+    class StringEnum extends Generic {
+        options;
+        defaultValue;
+        constructor(options, defaultValue) {
+            super();
+            this.options = options;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.StringEnum = StringEnum;
+    function stringEnum(options, defaultValue) {
+        return new StringEnum(options, defaultValue);
+    }
+    KokimokiSchema.stringEnum = stringEnum;
+    class StringConst extends Generic {
+        defaultValue;
+        constructor(defaultValue) {
+            super();
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.StringConst = StringConst;
+    function stringConst(defaultValue) {
+        return new StringConst(defaultValue);
+    }
+    KokimokiSchema.stringConst = stringConst;
+    class AnyOf extends Generic {
+        schemas;
+        defaultValue;
+        constructor(schemas, defaultValue) {
+            super();
+            this.schemas = schemas;
+            this.defaultValue = defaultValue;
+        }
+    }
+    KokimokiSchema.AnyOf = AnyOf;
+    function anyOf(schemas, defaultValue) {
+        return new AnyOf(schemas, defaultValue);
+    }
+    KokimokiSchema.anyOf = anyOf;
 })(KokimokiSchema || (KokimokiSchema = {}));

package/dist/kokimoki-transaction.d.ts

@@ -10,7 +10,7 @@ export declare class KokimokiTransaction {
     private _parseTarget;
     private _parsePath;
     private _getClone;
-    get<T>(target: T): any;
+    get<T>(target: T): T;
     set<T>(target: T, value: T): void;
     delete<T>(target: T): void;
     push<T>(target: T[], value: T): void;

package/dist/synced-schema.d.ts

@@ -1,52 +1,59 @@
-export declare namespace S {
-    abstract class Generic<T> {
-        abstract get defaultValue(): T;
-        abstract set defaultValue(value: T);
-    }
-    class Number extends Generic<number> {
-        defaultValue: number;
-        constructor(defaultValue?: number);
-    }
-    function number(defaultValue?: number): Number;
-    class String extends Generic<string> {
-        defaultValue: string;
-        constructor(defaultValue?: string);
-    }
-    function string(defaultValue?: string): String;
-    class Boolean extends Generic<boolean> {
-        defaultValue: boolean;
-        constructor(defaultValue?: boolean);
-    }
-    function boolean(defaultValue?: boolean): Boolean;
-    class Struct<Data extends Record<string, Generic<unknown>>> extends Generic<{
+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"];
-    }> {
-        fields: Data;
-        constructor(fields: Data);
-        get defaultValue(): {
-            [key in keyof Data]: Data[key]["defaultValue"];
-        };
-        set defaultValue(value: {
-            [key in keyof Data]: Data[key]["defaultValue"];
-        });
-    }
-    function struct<Data extends Record<string, Generic<unknown>>>(schema: Data): Struct<Data>;
-    class Dict<T extends Generic<unknown>> {
-        schema: T;
-        defaultValue: {
-            [key: string]: T["defaultValue"];
-        };
-        constructor(schema: T, defaultValue?: {
-            [key: string]: T["defaultValue"];
-        });
-    }
-    function dict<T extends Generic<unknown>>(schema: T, 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"];
-    }): Dict<T>;
-    class List<T extends Generic<unknown>> extends Generic<T["defaultValue"][]> {
-        schema: T;
-        defaultValue: T["defaultValue"][];
-        constructor(schema: T, defaultValue?: T["defaultValue"][]);
-    }
-    function list<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"][]): List<T>;
+    };
+    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,92 +1,84 @@
-export var S;
-(function (S) {
-    class Generic {
+export class SyncedGeneric {
+}
+export class SyncedNumber extends SyncedGeneric {
+    defaultValue;
+    constructor(defaultValue = 0) {
+        super();
+        this.defaultValue = defaultValue;
     }
-    S.Generic = Generic;
-    class Number extends Generic {
-        defaultValue;
-        constructor(defaultValue = 0) {
-            super();
-            this.defaultValue = defaultValue;
-        }
-    }
-    S.Number = Number;
-    function number(defaultValue = 0) {
-        return new Number(defaultValue);
-    }
-    S.number = number;
-    class String extends Generic {
-        defaultValue;
-        constructor(defaultValue = "") {
-            super();
-            this.defaultValue = defaultValue;
-        }
-    }
-    S.String = String;
-    function string(defaultValue = "") {
-        return new String(defaultValue);
-    }
-    S.string = string;
-    class Boolean extends Generic {
-        defaultValue;
-        constructor(defaultValue = false) {
-            super();
-            this.defaultValue = defaultValue;
-        }
+}
+function syncedNumber(defaultValue = 0) {
+    return new SyncedNumber(defaultValue);
+}
+export class SyncedString extends SyncedGeneric {
+    defaultValue;
+    constructor(defaultValue = "") {
+        super();
+        this.defaultValue = defaultValue;
     }
-    S.Boolean = Boolean;
-    function boolean(defaultValue = false) {
-        return new Boolean(defaultValue);
+}
+function syncedString(defaultValue = "") {
+    return new SyncedString(defaultValue);
+}
+export class SyncedBoolean extends SyncedGeneric {
+    defaultValue;
+    constructor(defaultValue = false) {
+        super();
+        this.defaultValue = defaultValue;
     }
-    S.boolean = boolean;
-    class Struct extends Generic {
-        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 syncedBoolean(defaultValue = false) {
+    return new SyncedBoolean(defaultValue);
+}
+export class SyncedObject extends SyncedGeneric {
+    fields;
+    constructor(fields) {
+        super();
+        this.fields = fields;
     }
-    S.Struct = Struct;
-    function struct(schema) {
-        return new Struct(schema);
+    get defaultValue() {
+        return Object.entries(this.fields).reduce((acc, [key, field]) => {
+            acc[key] = field.defaultValue;
+            return acc;
+        }, {});
     }
-    S.struct = struct;
-    class Dict {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = {}) {
-            this.schema = schema;
-            this.defaultValue = defaultValue;
+    set defaultValue(value) {
+        for (const [key, field] of Object.entries(this.fields)) {
+            field.defaultValue = value[key];
         }
     }
-    S.Dict = Dict;
-    function dict(schema, defaultValue = {}) {
-        return new Dict(schema, defaultValue);
-    }
-    S.dict = dict;
-    class List extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = []) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
+}
+function syncedObject(schema) {
+    return new SyncedObject(schema);
+}
+export class SyncedMap {
+    schema;
+    defaultValue;
+    constructor(schema, defaultValue = {}) {
+        this.schema = schema;
+        this.defaultValue = defaultValue;
     }
-    S.List = List;
-    function list(schema, defaultValue = []) {
-        return new List(schema, 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;
     }
-    S.list = list;
-})(S || (S = {}));
+}
+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-types.d.ts

@@ -36,10 +36,3 @@ export declare class SyncedArray<T extends SyncedGeneric<unknown>> extends Synce
     constructor(schema: T, defaultValue?: T["defaultValue"][]);
 }
 export 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;
-    map: typeof syncedMap;
-    array: typeof syncedArray;
-};

package/dist/synced-types.js

@@ -1,3 +1,6 @@
+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 {
@@ -63,10 +66,3 @@ export class SyncedArray extends SyncedGeneric {
 export function syncedArray(schema, defaultValue = []) {
     return new SyncedArray(schema, defaultValue);
 }
-export const S = {
-    number: syncedNumber,
-    string: syncedString,
-    boolean: syncedBoolean,
-    map: syncedMap,
-    array: syncedArray,
-};

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "1.0.2";
+export declare const KOKIMOKI_APP_VERSION = "1.0.4";

package/dist/version.js

@@ -1 +1 @@
-export const KOKIMOKI_APP_VERSION = "1.0.2";
+export const KOKIMOKI_APP_VERSION = "1.0.4";

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/ws-message-type.js → ws-message-type copy.js }

@@ -2,4 +2,6 @@ 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.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",

package/dist/kokimoki-client copy.d.ts

@@ -1,57 +0,0 @@
-import { HocuspocusProvider } from "@hocuspocus/provider";
-import type TypedEmitter from "typed-emitter";
-import type { SyncedStore } from "./synced-store";
-import type { DocTypeDescription } from "@syncedstore/core/types/doc";
-import type { KokimokiClientEvents } from "./types/events";
-import type { Upload } from "./types/upload";
-import type { Paginated } from "./types/common";
-declare const KokimokiClient_base: new <T>() => TypedEmitter<KokimokiClientEvents<T>>;
-export declare class KokimokiClient<StatelessDataT = any, ClientContextT = any> extends KokimokiClient_base<StatelessDataT> {
-    readonly host: string;
-    readonly appId: string;
-    readonly code: string;
-    private _wsUrl;
-    private _apiUrl;
-    private _id?;
-    private _token?;
-    private _apiHeaders?;
-    private _providers;
-    private _serverTimeOffset;
-    private _clientContext?;
-    private _connected;
-    private _lastPongAt;
-    constructor(host: string, appId: string, code?: string);
-    get id(): string;
-    get token(): string;
-    get apiUrl(): string;
-    get apiHeaders(): Headers;
-    get clientContext(): ClientContextT & ({} | null);
-    connect(): Promise<void>;
-    serverTimestamp(): number;
-    private receivePong;
-    private checkConnectionState;
-    setProvider<T extends DocTypeDescription>(name: string, store: SyncedStore<T>): Promise<void>;
-    removeProvider(name: string): void;
-    getProvider(name: string): HocuspocusProvider | undefined;
-    sendStatelessToClient(room: string, clientId: string, data: StatelessDataT): void;
-    sendStatelessToRoom(room: string, data: StatelessDataT, self?: boolean): void;
-    patchRoomState(room: string, update: Uint8Array): Promise<any>;
-    private createUpload;
-    private uploadChunks;
-    private completeUpload;
-    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
-    updateUpload(id: string, update: {
-        tags?: string[];
-    }): Promise<Upload>;
-    listUploads(filter?: {
-        clientId?: string;
-        mimeTypes?: string[];
-        tags?: string[];
-    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
-    deleteUpload(id: string): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-    exposeScriptingContext(context: any): Promise<void>;
-}
-export {};

package/dist/kokimoki-client copy.js

@@ -1,259 +0,0 @@
-import { HocuspocusProvider } from "@hocuspocus/provider";
-import EventEmitter from "events";
-import { KOKIMOKI_APP_VERSION } from "./version";
-export class KokimokiClient extends EventEmitter {
-    host;
-    appId;
-    code;
-    _wsUrl;
-    _apiUrl;
-    _id;
-    _token;
-    _apiHeaders;
-    _providers = new Map();
-    _serverTimeOffset = 0;
-    _clientContext;
-    _connected = false;
-    _lastPongAt = 0;
-    constructor(host, appId, code = "") {
-        super();
-        this.host = host;
-        this.appId = appId;
-        this.code = code;
-        // Set up the URLs
-        const secure = this.host.indexOf(":") === -1;
-        this._wsUrl = `ws${secure ? "s" : ""}://${this.host}`;
-        this._apiUrl = `http${secure ? "s" : ""}://${this.host}`;
-    }
-    get id() {
-        if (!this._id) {
-            throw new Error("Client not connected");
-        }
-        return this._id;
-    }
-    get token() {
-        if (!this._token) {
-            throw new Error("Client not connected");
-        }
-        return this._token;
-    }
-    get apiUrl() {
-        if (!this._apiUrl) {
-            throw new Error("Client not connected");
-        }
-        return this._apiUrl;
-    }
-    get apiHeaders() {
-        if (!this._apiHeaders) {
-            throw new Error("Client not connected");
-        }
-        return this._apiHeaders;
-    }
-    get clientContext() {
-        if (this._clientContext === undefined) {
-            throw new Error("Client not connected");
-        }
-        return this._clientContext;
-    }
-    async connect() {
-        // Fetch the auth token
-        let clientToken = localStorage.getItem("KM_TOKEN");
-        const startTime = Date.now();
-        const res = await fetch(`${this.apiUrl}/auth/token?appId=${this.appId}&code=${this.code}&clientVersion=${KOKIMOKI_APP_VERSION}`, {
-            method: "GET",
-            headers: new Headers({
-                "Content-Type": "application/json",
-                Authorization: `Bearer ${clientToken}`,
-            }),
-        });
-        const { clientId, appToken, serverTime, token, clientContext } = await res.json();
-        const endTime = Date.now();
-        const ping = Math.round((endTime - startTime) / 2);
-        this._id = clientId;
-        this._token = appToken;
-        this._serverTimeOffset = Date.now() - serverTime - ping;
-        this._clientContext = clientContext;
-        localStorage.setItem("KM_TOKEN", token);
-        // Set up the auth headers
-        this._apiHeaders = new Headers({
-            Authorization: `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-        });
-        // Ping interval
-        setInterval(() => {
-            this._providers.forEach((provider) => provider.sendStateless("ping"));
-        }, 5000);
-        // Connection state interval
-        setInterval(() => {
-            this.checkConnectionState();
-        }, 1000);
-        // Check initial connected state
-        this.receivePong();
-    }
-    serverTimestamp() {
-        return Date.now() - this._serverTimeOffset;
-    }
-    receivePong() {
-        this._lastPongAt = Date.now();
-        this.checkConnectionState();
-    }
-    checkConnectionState() {
-        const connected = this._providers.size === 0 || Date.now() - this._lastPongAt < 6000;
-        if (connected && !this._connected) {
-            this._connected = true;
-            this.emit("connected");
-        }
-        else if (!connected && this._connected) {
-            this._connected = false;
-            this.emit("disconnected");
-            // Reset connections to providers
-            this._providers.forEach(async (provider) => {
-                provider.disconnect();
-                await provider.connect();
-            });
-        }
-    }
-    // Realtime database
-    async setProvider(name, store) {
-        const provider = new HocuspocusProvider({
-            url: `${this._wsUrl}/connection`,
-            name: `${this.appId}/${name}`,
-            document: store.doc,
-            token: this.token,
-            parameters: {
-                clientVersion: KOKIMOKI_APP_VERSION,
-            },
-        });
-        // Handle incoming stateless messages
-        provider.on("stateless", (e) => {
-            if (e.payload === "pong") {
-                this.receivePong();
-                return;
-            }
-            const payload = JSON.parse(e.payload);
-            this.emit("stateless", name, payload.from, payload.data);
-        });
-        // Wait for initial sync
-        await new Promise((resolve) => {
-            const handler = () => {
-                provider.off("synced", handler);
-                resolve();
-            };
-            provider.on("synced", handler);
-        });
-        this._lastPongAt = Date.now();
-        this._providers.set(name, provider);
-        this.checkConnectionState();
-    }
-    removeProvider(name) {
-        const provider = this._providers.get(name);
-        if (!provider) {
-            throw new Error(`No provider for room ${name}`);
-        }
-        provider.destroy();
-        this._providers.delete(name);
-        // Connection state can change if the removed provider was not connected or synced
-        this.checkConnectionState();
-    }
-    getProvider(name) {
-        return this._providers.get(name);
-    }
-    sendStatelessToClient(room, clientId, data) {
-        const provider = this._providers.get(room);
-        if (!provider) {
-            throw new Error(`No provider for room ${room}`);
-        }
-        provider.sendStateless(JSON.stringify({ to: clientId, data }));
-    }
-    sendStatelessToRoom(room, data, self = false) {
-        const provider = this._providers.get(room);
-        if (!provider) {
-            throw new Error(`No provider for room ${room}`);
-        }
-        provider.sendStateless(JSON.stringify({ data, self }));
-    }
-    // Send Y update to room
-    async patchRoomState(room, update) {
-        const res = await fetch(`${this._apiUrl}/rooms/${room}`, {
-            method: "PATCH",
-            headers: this.apiHeaders,
-            body: update,
-        });
-        return await res.json();
-    }
-    // Storage
-    async createUpload(name, blob, tags) {
-        const res = await fetch(`${this._apiUrl}/uploads`, {
-            method: "POST",
-            headers: this.apiHeaders,
-            body: JSON.stringify({
-                name,
-                size: blob.size,
-                mimeType: blob.type,
-                tags,
-            }),
-        });
-        return await res.json();
-    }
-    async uploadChunks(blob, chunkSize, signedUrls) {
-        return await Promise.all(signedUrls.map(async (url, index) => {
-            const start = index * chunkSize;
-            const end = Math.min(start + chunkSize, blob.size);
-            const chunk = blob.slice(start, end);
-            const res = await fetch(url, { method: "PUT", body: chunk });
-            return JSON.parse(res.headers.get("ETag") || '""');
-        }));
-    }
-    async completeUpload(id, etags) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.apiHeaders,
-            body: JSON.stringify({ etags }),
-        });
-        return await res.json();
-    }
-    async upload(name, blob, tags = []) {
-        const { id, chunkSize, urls } = await this.createUpload(name, blob, tags);
-        const etags = await this.uploadChunks(blob, chunkSize, urls);
-        return await this.completeUpload(id, etags);
-    }
-    async updateUpload(id, update) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.apiHeaders,
-            body: JSON.stringify(update),
-        });
-        return await res.json();
-    }
-    async listUploads(filter = {}, skip = 0, limit = 100) {
-        const url = new URL("/uploads", this._apiUrl);
-        url.searchParams.set("skip", skip.toString());
-        url.searchParams.set("limit", limit.toString());
-        if (filter.clientId) {
-            url.searchParams.set("clientId", filter.clientId);
-        }
-        if (filter.mimeTypes) {
-            url.searchParams.set("mimeTypes", filter.mimeTypes.join());
-        }
-        if (filter.tags) {
-            url.searchParams.set("tags", filter.tags.join());
-        }
-        const res = await fetch(url.href, {
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async deleteUpload(id) {
-        const res = await fetch(`${this._apiUrl}/uploads/${id}`, {
-            method: "DELETE",
-            headers: this.apiHeaders,
-        });
-        return await res.json();
-    }
-    async exposeScriptingContext(context) {
-        // @ts-ignore
-        window.KM_SCRIPTING_CONTEXT = context;
-        // @ts-ignore
-        window.dispatchEvent(new CustomEvent("km:scriptingContextExposed"));
-    }
-}

package/dist/synced-store copy.d.ts

@@ -1,7 +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 copy.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/ws-message/index.d.ts

@@ -1,3 +0,0 @@
-export * from "../ws-message-type";
-export * from "../ws-message-reader";
-export * from "../ws-message-writer";

package/dist/ws-message/index.js

@@ -1,3 +0,0 @@
-export * from "../ws-message-type";
-export * from "../ws-message-reader";
-export * from "../ws-message-writer";

package/dist/ws-message/ws-message-reader.d.ts

@@ -1,9 +0,0 @@
-import type { WsMessageType } from "./ws-message-type";
-export declare class WsMessageReader {
-    private buffer;
-    readonly type: WsMessageType;
-    private _view;
-    private _offset;
-    constructor(buffer: ArrayBuffer);
-    readInt32(): number;
-}

package/dist/ws-message/ws-message-reader.js

@@ -1,17 +0,0 @@
-export class WsMessageReader {
-    buffer;
-    type;
-    _view;
-    _offset = 0;
-    constructor(buffer) {
-        this.buffer = buffer;
-        // Read the first 4 bytes as the message type
-        this._view = new DataView(buffer);
-        this.type = this.readInt32();
-    }
-    readInt32() {
-        const value = this._view.getInt32(this._offset, true);
-        this._offset += 4;
-        return value;
-    }
-}

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

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

package/dist/ws-message/ws-message-writer.d.ts

@@ -1,12 +0,0 @@
-import type { WsMessageType } from "./ws-message-type";
-export declare class WsMessageWriter {
-    type: WsMessageType;
-    payloadLength: number;
-    private _buffer;
-    private _view;
-    private _offset;
-    constructor(type: WsMessageType, payloadLength: number);
-    writeInt32(value: number): void;
-    writeString(value: string): void;
-    get buffer(): ArrayBuffer;
-}

package/dist/ws-message/ws-message-writer.js

@@ -1,30 +0,0 @@
-export class WsMessageWriter {
-    type;
-    payloadLength;
-    _buffer;
-    _view;
-    _offset = 0;
-    constructor(type, payloadLength) {
-        this.type = type;
-        this.payloadLength = payloadLength;
-        this._buffer = new ArrayBuffer(4 + payloadLength);
-        this._view = new DataView(this._buffer);
-        // Write type
-        this.writeInt32(type);
-    }
-    writeInt32(value) {
-        this._view.setInt32(this._offset, value, true);
-        this._offset += 4;
-    }
-    writeString(value) {
-        // Write length
-        this.writeInt32(value.length);
-        // Write chars
-        for (let i = 0; i < value.length; i++) {
-            this._view.setUint8(this._offset++, value.charCodeAt(i));
-        }
-    }
-    get buffer() {
-        return this._buffer;
-    }
-}

package/dist/ws-message.d.ts

@@ -1,14 +0,0 @@
-export declare enum WsMessageType {
-    Subscribe = 1
-}
-export declare class WsMessage {
-    type: WsMessageType;
-    payloadLength: number;
-    private _buffer;
-    private _view;
-    private _offset;
-    constructor(type: WsMessageType, payloadLength: number);
-    writeInt32(value: number): void;
-    writeString(value: string): void;
-    get buffer(): ArrayBuffer;
-}

package/dist/ws-message.js

@@ -1,34 +0,0 @@
-export var WsMessageType;
-(function (WsMessageType) {
-    WsMessageType[WsMessageType["Subscribe"] = 1] = "Subscribe";
-})(WsMessageType || (WsMessageType = {}));
-export class WsMessage {
-    type;
-    payloadLength;
-    _buffer;
-    _view;
-    _offset = 0;
-    constructor(type, payloadLength) {
-        this.type = type;
-        this.payloadLength = payloadLength;
-        this._buffer = new ArrayBuffer(4 + payloadLength);
-        this._view = new DataView(this._buffer);
-        // Write type
-        this.writeInt32(type);
-    }
-    writeInt32(value) {
-        this._view.setInt32(this._offset, value, true);
-        this._offset += 4;
-    }
-    writeString(value) {
-        // Write length
-        this.writeInt32(value.length);
-        // Write chars
-        for (let i = 0; i < value.length; i++) {
-            this._view.setUint8(this._offset++, value.charCodeAt(i));
-        }
-    }
-    get buffer() {
-        return this._buffer;
-    }
-}