@kokimoki/app 0.6.8 → 1.0.0

package/dist/kokimoki-store.js

@@ -0,0 +1,48 @@
+import * as Y from "yjs";
+import { proxy as yjsProxy } from "valtio";
+import { bind as yjsBind } from "valtio-yjs";
+import DeepProxy from "proxy-deep";
+import { RoomSubscriptionMode } from "./room-subscription-mode";
+export class KokimokiStore {
+    roomName;
+    mode;
+    doc;
+    proxy;
+    root;
+    defaultValue;
+    docRoot;
+    constructor(roomName, schema, mode = RoomSubscriptionMode.ReadWrite) {
+        this.roomName = roomName;
+        this.mode = mode;
+        // Construct Y doc
+        this.doc = new Y.Doc();
+        // Construct proxy object
+        this.docRoot = this.doc.getMap("root");
+        this.proxy = yjsProxy();
+        // @ts-ignore
+        yjsBind(this.proxy, this.docRoot);
+        // Create root proxy
+        const store = this;
+        // @ts-ignore
+        this.root = new DeepProxy(this.proxy, {
+            get() {
+                return this.nest(function () { });
+            },
+            apply() {
+                let obj = store.proxy;
+                for (let i = 0; i < this.path.length - 1; i++) {
+                    obj = obj[this.path[i]];
+                }
+                return {
+                    roomName: store.roomName,
+                    doc: store.doc,
+                    path: this.path,
+                    obj,
+                    key: this.path[this.path.length - 1],
+                };
+            },
+        });
+        // Set default value
+        this.defaultValue = schema.defaultValue;
+    }
+}

package/dist/kokimoki-transaction.d.ts

@@ -0,0 +1,25 @@
+import type { KokimokiQueue } from "./kokimoki-queue";
+import type { KokimokiSchema as S } from "./kokimoki-schema";
+import type { KokimokiClient } from "./kokimoki-client";
+export declare class KokimokiTransaction {
+    private kmClient;
+    private _clones;
+    private _updates;
+    private _consumeMessagesInRooms;
+    constructor(kmClient: KokimokiClient<any>);
+    private _parseTarget;
+    private _parsePath;
+    private _getClone;
+    set<T>(target: T, value: T): void;
+    delete<T>(target: T): void;
+    push<T>(target: T[], value: T): void;
+    queueMessage<T>(queue: KokimokiQueue<S.Generic<T>>, payload: T): void;
+    consumeMessage<T>(queue: KokimokiQueue<S.Generic<T>>, messageId: string): void;
+    getUpdates(): Promise<{
+        updates: {
+            roomName: string;
+            update: Uint8Array;
+        }[];
+        consumedMessages: Set<string>;
+    }>;
+}

package/dist/kokimoki-transaction.js

@@ -0,0 +1,99 @@
+import * as Y from "yjs";
+import { proxy as yjsProxy } from "valtio";
+import { bind as yjsBind } from "valtio-yjs";
+export class KokimokiTransaction {
+    kmClient;
+    _clones = new Map();
+    _updates = new Map();
+    _consumeMessagesInRooms = new Set();
+    constructor(kmClient) {
+        this.kmClient = kmClient;
+    }
+    _parseTarget(target) {
+        return target();
+    }
+    _parsePath(obj, path) {
+        for (let i = 0; i < path.length - 1; i++) {
+            if (!(path[i] in obj)) {
+                obj[path[i]] = {};
+            }
+            obj = obj[path[i]];
+        }
+        return { obj, key: path[path.length - 1] };
+    }
+    _getClone(roomName, doc) {
+        if (!this._clones.has(roomName)) {
+            // Clone doc
+            const docClone = new Y.Doc();
+            const docRoot = docClone.getMap("root");
+            Y.applyUpdate(docClone, Y.encodeStateAsUpdate(doc));
+            // Set up proxy
+            const proxyClone = yjsProxy();
+            const unbindProxy = yjsBind(proxyClone, docRoot);
+            // Listen for updates
+            docClone.on("update", (update) => {
+                if (this._updates.has(roomName)) {
+                    const prevUpdate = this._updates.get(roomName);
+                    const nextUpdate = Y.mergeUpdates([prevUpdate, update]);
+                    this._updates.set(roomName, nextUpdate);
+                }
+                else {
+                    this._updates.set(roomName, update);
+                }
+            });
+            this._clones.set(roomName, { docClone, proxyClone, unbindProxy });
+        }
+        return this._clones.get(roomName);
+    }
+    set(target, value) {
+        const { roomName, doc, path } = this._parseTarget(target);
+        const { proxyClone } = this._getClone(roomName, doc);
+        const { obj, key } = this._parsePath(proxyClone, path);
+        obj[key] = value;
+    }
+    delete(target) {
+        const { roomName, doc, path } = this._parseTarget(target);
+        const { proxyClone } = this._getClone(roomName, doc);
+        const { obj, key } = this._parsePath(proxyClone, path);
+        delete obj[key];
+    }
+    push(target, value) {
+        const { roomName, doc, path } = this._parseTarget(target);
+        const { proxyClone } = this._getClone(roomName, doc);
+        const { obj, key } = this._parsePath(proxyClone, path);
+        if (!(key in obj)) {
+            obj[key] = [];
+        }
+        obj[key].push(value);
+    }
+    queueMessage(queue, payload) {
+        const messageId = Math.random().toString(36);
+        this.set(queue.root[messageId], {
+            timestamp: this.kmClient.serverTimestamp(),
+            payload,
+        });
+    }
+    consumeMessage(queue, messageId) {
+        if (!queue.proxy[messageId]) {
+            throw new Error(`Message ${messageId} does not exist or has already been consumed`);
+        }
+        this.delete(queue.root[messageId]);
+        this._consumeMessagesInRooms.add(queue.roomName);
+    }
+    async getUpdates() {
+        // Wait for doc update handling to finish
+        return await new Promise((resolve) => setTimeout(() => {
+            // Clean up
+            for (const { unbindProxy } of this._clones.values()) {
+                unbindProxy();
+            }
+            // Generates updates
+            const updates = Array.from(this._updates.entries()).map(([roomName, update]) => ({
+                roomName,
+                update,
+            }));
+            // Done
+            resolve({ updates, consumedMessages: this._consumeMessagesInRooms });
+        }));
+    }
+}

package/dist/message-queue.d.ts

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

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

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

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

package/dist/room-subscription-mode.js

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

package/dist/room-subscription.d.ts

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

package/dist/room-subscription.js

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

package/dist/synced-schema.d.ts

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

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

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

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

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

package/dist/synced-types.js

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

package/dist/types/events.d.ts

@@ -1,5 +1,4 @@
-export type KokimokiClientEvents<T> = {
-    stateless: (room: string, from: string, data: T) => void;
+export type KokimokiClientEvents = {
     connected: () => void;
     disconnected: () => void;
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "0.6.8";
+export declare const KOKIMOKI_APP_VERSION = "1.0.0";

package/dist/version.js

@@ -1 +1 @@
-export const KOKIMOKI_APP_VERSION = "0.6.8";
+export const KOKIMOKI_APP_VERSION = "1.0.0";

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

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

package/dist/ws-message/index.js

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+export var WsMessageType;
+(function (WsMessageType) {
+    WsMessageType[WsMessageType["SubscribeReq"] = 1] = "SubscribeReq";
+    WsMessageType[WsMessageType["SubscribeRes"] = 2] = "SubscribeRes";
+})(WsMessageType || (WsMessageType = {}));

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

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

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