@kokimoki/app 1.4.7 → 1.6.0

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "1.4.7";
+export declare const KOKIMOKI_APP_VERSION = "1.6.0";

package/dist/version.js

@@ -1 +1 @@
-export const KOKIMOKI_APP_VERSION = "1.4.7";
+export const KOKIMOKI_APP_VERSION = "1.6.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "1.4.7",
+  "version": "1.6.0",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "events": "^3.3.0",
+    "farmhash-modern": "^1.1.0",
     "proxy-deep": "^4.0.1",
     "typed-emitter": "^2.1.0",
     "valtio": "^1.13.1",

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

@@ -1,68 +0,0 @@
-import type TypedEmitter from "typed-emitter";
-import type { KokimokiClientEventsRefactored } from "./types/events";
-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 { SyncedGeneric } from "./synced-schema";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-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;
-    private _wsUrl;
-    private _apiUrl;
-    private _id?;
-    private _token?;
-    private _apiHeaders?;
-    private _serverTimeOffset;
-    private _clientContext?;
-    private _ws?;
-    private _subscriptions;
-    private _stores;
-    private _reqPromises;
-    private _transactionResolves;
-    private _roomHashes;
-    private _roomHashToDoc;
-    private _connected;
-    private _connectPromise?;
-    private _messageId;
-    constructor(host: string, appId: string, code?: string);
-    get id(): string;
-    get token(): string;
-    get apiUrl(): string;
-    get apiHeaders(): Headers;
-    get clientContext(): ClientContextT & ({} | null);
-    get connected(): boolean;
-    get ws(): WebSocket;
-    connect(): Promise<void>;
-    private handleInitMessage;
-    private handleBinaryMessage;
-    private handleErrorMessage;
-    private handleSubscribeResMessage;
-    private handleRoomUpdateMessage;
-    serverTimestamp(): number;
-    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>;
-    private sendSubscriptionReq;
-    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

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

package/dist/synced-schema.js

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

package/dist/synced-store.d.ts

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