@kokimoki/app 1.0.2 → 1.0.5

package/dist/kokimoki-client-refactored.js

@@ -1,422 +0,0 @@
-import EventEmitter from "events";
-import { KOKIMOKI_APP_VERSION } from "./version";
-import * as Y from "yjs";
-import { KokimokiTransaction } from "./kokimoki-transaction";
-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 {
-    host;
-    appId;
-    code;
-    _wsUrl;
-    _apiUrl;
-    _id;
-    _token;
-    _apiHeaders;
-    _serverTimeOffset = 0;
-    _clientContext;
-    _ws;
-    _subscriptionsByName = new Map();
-    _subscriptionsByHash = new Map();
-    _subscribeReqPromises = new Map();
-    _transactionPromises = new Map();
-    _connected = false;
-    _connectPromise;
-    _messageId = 0;
-    _reconnectTimeout = 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;
-    }
-    get connected() {
-        return this._connected;
-    }
-    get ws() {
-        if (!this._ws) {
-            throw new Error("Not connected");
-        }
-        return this._ws;
-    }
-    async connect() {
-        if (this._connectPromise) {
-            return await this._connectPromise;
-        }
-        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");
-            // Send the app token on first connect
-            this.ws.onopen = () => {
-                this.ws.send(JSON.stringify({ type: "auth", code: this.code, token: clientToken }));
-            };
-            this.ws.onclose = () => {
-                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);
-                // Emit disconnected event
-                this.emit("disconnected");
-            };
-            this.ws.onmessage = (e) => {
-                console.log(`Received WS message: ${e.data}`);
-                // Handle JSON messages
-                if (typeof e.data === "string") {
-                    const message = JSON.parse(e.data);
-                    switch (message.type) {
-                        case "serverTime": {
-                            this._serverTimeOffset = Date.now() - message.serverTime;
-                            console.log(`Server time offset: ${this._serverTimeOffset}`);
-                            break;
-                        }
-                        case "init":
-                            this.handleInitMessage(message);
-                            onInit();
-                            break;
-                    }
-                    return;
-                }
-                // Handle binary messages
-                this.handleBinaryMessage(e.data);
-            };
-        });
-        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);
-        this._id = message.clientId;
-        this._token = message.appToken;
-        this._clientContext = message.clientContext;
-        // Set up the auth headers
-        this._apiHeaders = new Headers({
-            Authorization: `Bearer ${this.token}`,
-            "Content-Type": "application/json",
-        });
-    }
-    handleBinaryMessage(data) {
-        const reader = new WsMessageReader(data);
-        const type = reader.readInt32();
-        switch (type) {
-            case WsMessageType.SubscribeRes:
-                this.handleSubscribeResMessage(reader);
-                break;
-            case WsMessageType.RoomUpdate:
-                this.handleRoomUpdateMessage(reader);
-                break;
-            case WsMessageType.Error:
-                this.handleErrorMessage(reader);
-                break;
-        }
-    }
-    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);
-        }
-        else {
-            console.warn(`Received error for unknown request ${reqId}: ${error}`);
-        }
-    }
-    handleSubscribeResMessage(msg) {
-        const reqId = msg.readInt32();
-        const roomHash = msg.readUint32();
-        const promise = this._subscribeReqPromises.get(reqId);
-        if (promise) {
-            this._subscribeReqPromises.delete(reqId);
-            // In Write mode, no initial state is sent
-            if (!msg.end) {
-                promise.resolve(roomHash, msg.readUint8Array());
-            }
-            else {
-                promise.resolve(roomHash);
-            }
-        }
-    }
-    handleRoomUpdateMessage(msg) {
-        const appliedId = msg.readInt32();
-        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);
-            }
-            else {
-                console.warn(`Received update for unknown room ${roomHash}`);
-            }
-        }
-        // Check transaction resolves
-        for (const [transactionId, { resolve },] of this._transactionPromises.entries()) {
-            if (appliedId >= transactionId) {
-                this._transactionPromises.delete(transactionId);
-                resolve();
-            }
-        }
-    }
-    serverTimestamp() {
-        return Date.now() - this._serverTimeOffset;
-    }
-    // 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"));
-    }
-    async sendSubscriptionReq(roomName, mode) {
-        // Set up sync resolver
-        const reqId = ++this._messageId;
-        return await new Promise((resolve, reject) => {
-            this._subscribeReqPromises.set(reqId, {
-                resolve: (roomHash, initialUpdate) => {
-                    resolve({ roomHash, initialUpdate });
-                },
-                reject,
-            });
-            // Send subscription request
-            const msg = new WsMessageWriter();
-            msg.writeInt32(WsMessageType.SubscribeReq);
-            msg.writeInt32(reqId);
-            msg.writeString(roomName);
-            msg.writeChar(mode);
-            this.ws.send(msg.getBuffer());
-        });
-    }
-    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);
-        }
-        // Send subscription request if connected to server
-        if (!subscription.joined) {
-            const res = await this.sendSubscriptionReq(store.roomName, mode);
-            this._subscriptionsByHash.set(res.roomHash, subscription);
-            await subscription.applyInitialResponse(res.roomHash, res.initialUpdate);
-        }
-    }
-    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();
-        if (!updates.length) {
-            return;
-        }
-        // Construct buffer
-        const writer = new WsMessageWriter();
-        // Write message type
-        writer.writeInt32(WsMessageType.Transaction);
-        // 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) {
-                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
-            }
-            writer.writeUint32(subscription.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 });
-            // Send update to server
-            try {
-                this.ws.send(buffer);
-            }
-            catch (e) {
-                // Not connected
-                console.log("Failed to send update to server:", e);
-                // TODO: merge updates or something
-                throw e;
-            }
-        });
-        /* // Reset doc in Write-only mode
-        for (const { roomName, update } of updates) {
-          const mode = this._subscriptions.get(roomName);
-    
-          if (mode === RoomSubscriptionMode.Write) {
-            // @ts-ignore
-            // this._stores.get(this._roomHashes.get(roomName)!)!.doc = new Y.Doc();
-          }
-        } */
-    }
-}

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/synced-schema.d.ts

@@ -1,52 +0,0 @@
-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<{
-        [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?: {
-        [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>;
-}

package/dist/synced-schema.js

@@ -1,92 +0,0 @@
-export var S;
-(function (S) {
-    class Generic {
-    }
-    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;
-        }
-    }
-    S.Boolean = Boolean;
-    function boolean(defaultValue = false) {
-        return new Boolean(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];
-            }
-        }
-    }
-    S.Struct = Struct;
-    function struct(schema) {
-        return new Struct(schema);
-    }
-    S.struct = struct;
-    class Dict {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = {}) {
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    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;
-        }
-    }
-    S.List = List;
-    function list(schema, defaultValue = []) {
-        return new List(schema, defaultValue);
-    }
-    S.list = list;
-})(S || (S = {}));

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/synced-store.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.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,45 +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>;
-export declare const S: {
-    number: typeof syncedNumber;
-    string: typeof syncedString;
-    boolean: typeof syncedBoolean;
-    map: typeof syncedMap;
-    array: typeof syncedArray;
-};