@kokimoki/app 1.15.1 → 1.15.2

package/dist/kokimoki-client-refactored.js

@@ -1,394 +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";
-export class KokimokiClientRefactored extends EventEmitter {
-    host;
-    appId;
-    code;
-    _wsUrl;
-    _apiUrl;
-    _id;
-    _token;
-    _apiHeaders;
-    _serverTimeOffset = 0;
-    _clientContext;
-    _ws;
-    _subscriptions = new Map();
-    _stores = new Map();
-    _reqPromises = new Map();
-    _transactionResolves = new Map();
-    _roomHashes = new Map();
-    _roomHashToDoc = new Map();
-    _connected = false;
-    _connectPromise;
-    _messageId = 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";
-        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;
-                // Clean up
-                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}`);
-                // 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;
-    }
-    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",
-        });
-        this._connected = true;
-        this.emit("connected");
-    }
-    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 promise = this._reqPromises.get(reqId);
-        if (promise) {
-            this._reqPromises.delete(reqId);
-            promise.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._reqPromises.get(reqId);
-        if (promise) {
-            this._reqPromises.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 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._transactionResolves.entries()) {
-            if (appliedId >= transactionId) {
-                this._transactionResolves.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._reqPromises.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) {
-        if (this._subscriptions.has(store.roomName)) {
-            throw new Error(`Already joined room "${store.roomName}"`);
-        }
-        this._subscriptions.set(store.roomName, mode);
-        // Send req
-        try {
-            const res = await this.sendSubscriptionReq(store.roomName, mode);
-            // 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) {
-        const transaction = new KokimokiTransaction(this);
-        handler(transaction);
-        const updates = 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 updates
-        for (const { roomName, update } of updates) {
-            const roomHash = this._roomHashes.get(roomName);
-            if (!roomHash) {
-                throw new Error(`Cannot send update to "${roomName}" because it hasn't been joined`);
-            }
-            writer.writeUint32(roomHash);
-            writer.writeUint8Array(update);
-        }
-        const buffer = writer.getBuffer();
-        // Wait for server to apply transaction
-        await new Promise((resolve) => {
-            this._transactionResolves.set(transactionId, resolve);
-            // 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/kokimoki-schema.d.ts

@@ -1,84 +0,0 @@
-export declare namespace KokimokiSchema {
-    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>;
-    /**
-     * 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>;
-    class Optional<T extends Generic<unknown>> extends Generic<T["defaultValue"] | undefined> {
-        schema: T;
-        defaultValue: T["defaultValue"] | undefined;
-        constructor(schema: T, defaultValue?: T["defaultValue"] | undefined);
-    }
-    function optional<T extends Generic<unknown>>(schema: T, defaultValue?: T["defaultValue"] | undefined): Optional<T>;
-}

package/dist/kokimoki-schema.js

@@ -1,163 +0,0 @@
-export var KokimokiSchema;
-(function (KokimokiSchema) {
-    class Generic {
-    }
-    KokimokiSchema.Generic = Generic;
-    class Number extends Generic {
-        defaultValue;
-        constructor(defaultValue = 0) {
-            super();
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Number = Number;
-    function number(defaultValue = 0) {
-        return new Number(defaultValue);
-    }
-    KokimokiSchema.number = number;
-    class String extends Generic {
-        defaultValue;
-        constructor(defaultValue = "") {
-            super();
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.String = String;
-    function string(defaultValue = "") {
-        return new String(defaultValue);
-    }
-    KokimokiSchema.string = string;
-    class Boolean extends Generic {
-        defaultValue;
-        constructor(defaultValue = false) {
-            super();
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Boolean = Boolean;
-    function boolean(defaultValue = false) {
-        return new Boolean(defaultValue);
-    }
-    KokimokiSchema.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];
-            }
-        }
-    }
-    KokimokiSchema.Struct = Struct;
-    function struct(schema) {
-        return new Struct(schema);
-    }
-    KokimokiSchema.struct = struct;
-    class Dict {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = {}) {
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Dict = Dict;
-    function dict(schema, defaultValue = {}) {
-        return new Dict(schema, defaultValue);
-    }
-    KokimokiSchema.dict = dict;
-    class List extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = []) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.List = List;
-    function list(schema, defaultValue = []) {
-        return new List(schema, defaultValue);
-    }
-    KokimokiSchema.list = list;
-    /**
-     * Nullable
-     */
-    class Nullable extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Nullable = Nullable;
-    function nullable(schema, defaultValue = null) {
-        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;
-    class Optional extends Generic {
-        schema;
-        defaultValue;
-        constructor(schema, defaultValue = undefined) {
-            super();
-            this.schema = schema;
-            this.defaultValue = defaultValue;
-        }
-    }
-    KokimokiSchema.Optional = Optional;
-    function optional(schema, defaultValue = undefined) {
-        return new Optional(schema, defaultValue);
-    }
-    KokimokiSchema.optional = optional;
-})(KokimokiSchema || (KokimokiSchema = {}));

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;
-    }
-}