@kokimoki/app 3.1.3 → 3.1.5

package/dist/kokimoki-schema.d.ts

@@ -1,113 +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,162 +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/kokimoki-storage.d.ts

@@ -1,156 +0,0 @@
-import { KokimokiClient } from "./kokimoki-client";
-import { Paginated } from "./types/common";
-import { Upload } from "./types/upload";
-/**
- * Kokimoki Storage Service
- *
- * Provides file upload and management capabilities for game applications. Ideal for media files
- * (images, videos, audio) and other data not suitable for real-time stores (JSON, text files).
- *
- * **Key Features:**
- * - Upload files to cloud storage with CDN delivery
- * - Tag-based organization and filtering
- * - Query uploads by client, MIME type, or tags
- * - Pagination support for large collections
- * - Public CDN URLs for direct access
- *
- * **Common Use Cases:**
- * - Player avatars and profile images
- * - Game screenshots and replays
- * - User-generated content
- * - Asset uploads (levels, maps, custom skins)
- * - JSON configuration files
- *
- * Access via `kmClient.storage`
- *
- * @example
- * ```typescript
- * // Upload an image
- * const upload = await kmClient.storage.upload('avatar.jpg', imageBlob, ['profile']);
- *
- * // Query user's uploads
- * const myUploads = await kmClient.storage.listUploads({
- *   clientId: kmClient.id
- * });
- *
- * // Use in store
- * await kmClient.transact([store], (state) => {
- *   state.playerAvatar = upload.url;
- * });
- * ```
- */
-export declare class KokimokiStorage {
-    private readonly client;
-    constructor(client: KokimokiClient);
-    private createUpload;
-    private uploadChunks;
-    private completeUpload;
-    /**
-     * Upload a file to cloud storage.
-     *
-     * Uploads a file (Blob) to Kokimoki storage and returns an Upload object with a public CDN URL.
-     * Files are automatically chunked for efficient upload. The returned URL can be used directly
-     * in your application (e.g., in img tags or store state).
-     *
-     * @param name The filename for the upload
-     * @param blob The Blob object containing the file data
-     * @param tags Optional array of tags for organizing and filtering uploads (default: [])
-     * @returns A promise resolving to the Upload object with CDN URL and metadata
-     *
-     * @example
-     * ```typescript
-     * // Upload image with tags
-     * const upload = await kmClient.storage.upload(
-     *   'avatar.jpg',
-     *   imageBlob,
-     *   ['profile', 'avatar']
-     * );
-     *
-     * // Use the CDN URL
-     * console.log(upload.url); // https://cdn.kokimoki.com/...
-     *
-     * // Store in game state
-     * await kmClient.transact([store], (state) => {
-     *   state.players[kmClient.id].avatar = upload.url;
-     * });
-     * ```
-     */
-    upload(name: string, blob: Blob, tags?: string[]): Promise<Upload>;
-    /**
-     * Update metadata for an existing upload.
-     *
-     * Allows you to replace the tags associated with an upload. Useful for reorganizing
-     * or recategorizing uploaded files.
-     *
-     * @param id The upload ID to update
-     * @param update Object containing the new tags array
-     * @returns A promise resolving to the updated Upload object
-     *
-     * @example
-     * ```typescript
-     * // Update tags
-     * const updated = await kmClient.storage.updateUpload(upload.id, {
-     *   tags: ['archived', 'old-profile']
-     * });
-     * ```
-     */
-    updateUpload(id: string, update: {
-        tags?: string[];
-    }): Promise<Upload>;
-    /**
-     * Query uploaded files with filtering and pagination.
-     *
-     * Retrieves a list of uploads matching the specified criteria. Supports filtering by
-     * client (uploader), MIME types, and tags. Use pagination for large collections.
-     *
-     * @param filter Optional filter criteria
-     * @param filter.clientId Filter by uploader's client ID
-     * @param filter.mimeTypes Filter by MIME types (e.g., ['image/jpeg', 'image/png'])
-     * @param filter.tags Filter by tags (all specified tags must match)
-     * @param skip Number of results to skip for pagination (default: 0)
-     * @param limit Maximum number of results to return (default: 100)
-     * @returns A promise resolving to paginated Upload results with total count
-     *
-     * @example
-     * ```typescript
-     * // Get current user's images
-     * const myImages = await kmClient.storage.listUploads({
-     *   clientId: kmClient.id,
-     *   mimeTypes: ['image/jpeg', 'image/png']
-     * });
-     *
-     * // Get all profile avatars
-     * const avatars = await kmClient.storage.listUploads({
-     *   tags: ['profile', 'avatar']
-     * });
-     *
-     * // Pagination
-     * const page2 = await kmClient.storage.listUploads({}, 10, 10);
-     * ```
-     */
-    listUploads(filter?: {
-        clientId?: string;
-        mimeTypes?: string[];
-        tags?: string[];
-    }, skip?: number, limit?: number): Promise<Paginated<Upload>>;
-    /**
-     * Permanently delete an uploaded file.
-     *
-     * Removes the file from cloud storage and the CDN. The URL will no longer be accessible.
-     * This operation cannot be undone.
-     *
-     * @param id The upload ID to delete
-     * @returns A promise resolving to deletion confirmation
-     *
-     * @example
-     * ```typescript
-     * // Delete an upload
-     * const result = await kmClient.storage.deleteUpload(upload.id);
-     * console.log(`Deleted: ${result.deletedCount} file(s)`);
-     * ```
-     */
-    deleteUpload(id: string): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-}

package/dist/kokimoki-storage.js

@@ -1,208 +0,0 @@
-/**
- * Kokimoki Storage Service
- *
- * Provides file upload and management capabilities for game applications. Ideal for media files
- * (images, videos, audio) and other data not suitable for real-time stores (JSON, text files).
- *
- * **Key Features:**
- * - Upload files to cloud storage with CDN delivery
- * - Tag-based organization and filtering
- * - Query uploads by client, MIME type, or tags
- * - Pagination support for large collections
- * - Public CDN URLs for direct access
- *
- * **Common Use Cases:**
- * - Player avatars and profile images
- * - Game screenshots and replays
- * - User-generated content
- * - Asset uploads (levels, maps, custom skins)
- * - JSON configuration files
- *
- * Access via `kmClient.storage`
- *
- * @example
- * ```typescript
- * // Upload an image
- * const upload = await kmClient.storage.upload('avatar.jpg', imageBlob, ['profile']);
- *
- * // Query user's uploads
- * const myUploads = await kmClient.storage.listUploads({
- *   clientId: kmClient.id
- * });
- *
- * // Use in store
- * await kmClient.transact([store], (state) => {
- *   state.playerAvatar = upload.url;
- * });
- * ```
- */
-export class KokimokiStorage {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    // Storage
-    async createUpload(name, blob, tags) {
-        const res = await fetch(`${this.client.apiUrl}/uploads`, {
-            method: "POST",
-            headers: this.client.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.client.apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify({ etags }),
-        });
-        return await res.json();
-    }
-    /**
-     * Upload a file to cloud storage.
-     *
-     * Uploads a file (Blob) to Kokimoki storage and returns an Upload object with a public CDN URL.
-     * Files are automatically chunked for efficient upload. The returned URL can be used directly
-     * in your application (e.g., in img tags or store state).
-     *
-     * @param name The filename for the upload
-     * @param blob The Blob object containing the file data
-     * @param tags Optional array of tags for organizing and filtering uploads (default: [])
-     * @returns A promise resolving to the Upload object with CDN URL and metadata
-     *
-     * @example
-     * ```typescript
-     * // Upload image with tags
-     * const upload = await kmClient.storage.upload(
-     *   'avatar.jpg',
-     *   imageBlob,
-     *   ['profile', 'avatar']
-     * );
-     *
-     * // Use the CDN URL
-     * console.log(upload.url); // https://cdn.kokimoki.com/...
-     *
-     * // Store in game state
-     * await kmClient.transact([store], (state) => {
-     *   state.players[kmClient.id].avatar = upload.url;
-     * });
-     * ```
-     */
-    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);
-    }
-    /**
-     * Update metadata for an existing upload.
-     *
-     * Allows you to replace the tags associated with an upload. Useful for reorganizing
-     * or recategorizing uploaded files.
-     *
-     * @param id The upload ID to update
-     * @param update Object containing the new tags array
-     * @returns A promise resolving to the updated Upload object
-     *
-     * @example
-     * ```typescript
-     * // Update tags
-     * const updated = await kmClient.storage.updateUpload(upload.id, {
-     *   tags: ['archived', 'old-profile']
-     * });
-     * ```
-     */
-    async updateUpload(id, update) {
-        const res = await fetch(`${this.client.apiUrl}/uploads/${id}`, {
-            method: "PUT",
-            headers: this.client.apiHeaders,
-            body: JSON.stringify(update),
-        });
-        return await res.json();
-    }
-    /**
-     * Query uploaded files with filtering and pagination.
-     *
-     * Retrieves a list of uploads matching the specified criteria. Supports filtering by
-     * client (uploader), MIME types, and tags. Use pagination for large collections.
-     *
-     * @param filter Optional filter criteria
-     * @param filter.clientId Filter by uploader's client ID
-     * @param filter.mimeTypes Filter by MIME types (e.g., ['image/jpeg', 'image/png'])
-     * @param filter.tags Filter by tags (all specified tags must match)
-     * @param skip Number of results to skip for pagination (default: 0)
-     * @param limit Maximum number of results to return (default: 100)
-     * @returns A promise resolving to paginated Upload results with total count
-     *
-     * @example
-     * ```typescript
-     * // Get current user's images
-     * const myImages = await kmClient.storage.listUploads({
-     *   clientId: kmClient.id,
-     *   mimeTypes: ['image/jpeg', 'image/png']
-     * });
-     *
-     * // Get all profile avatars
-     * const avatars = await kmClient.storage.listUploads({
-     *   tags: ['profile', 'avatar']
-     * });
-     *
-     * // Pagination
-     * const page2 = await kmClient.storage.listUploads({}, 10, 10);
-     * ```
-     */
-    async listUploads(filter = {}, skip = 0, limit = 100) {
-        const url = new URL("/uploads", this.client.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.client.apiHeaders,
-        });
-        return await res.json();
-    }
-    /**
-     * Permanently delete an uploaded file.
-     *
-     * Removes the file from cloud storage and the CDN. The URL will no longer be accessible.
-     * This operation cannot be undone.
-     *
-     * @param id The upload ID to delete
-     * @returns A promise resolving to deletion confirmation
-     *
-     * @example
-     * ```typescript
-     * // Delete an upload
-     * const result = await kmClient.storage.deleteUpload(upload.id);
-     * console.log(`Deleted: ${result.deletedCount} file(s)`);
-     * ```
-     */
-    async deleteUpload(id) {
-        const res = await fetch(`${this.client.apiUrl}/uploads/${id}`, {
-            method: "DELETE",
-            headers: this.client.apiHeaders,
-        });
-        return await res.json();
-    }
-}

package/dist/kokimoki-store.d.ts

@@ -1,23 +0,0 @@
-import * as Y from "yjs";
-import { Snapshot } from "valtio/vanilla";
-import { RoomSubscriptionMode } from "./room-subscription-mode";
-import type { KokimokiClient } from "./kokimoki-client";
-export declare class KokimokiStore<T extends object> {
-    readonly roomName: string;
-    readonly defaultValue: T;
-    readonly mode: RoomSubscriptionMode;
-    readonly doc: Y.Doc;
-    readonly proxy: T;
-    readonly docRoot: Y.Map<unknown>;
-    readonly connections: {
-        connectionIds: Set<string>;
-        clientIds: Set<string>;
-    };
-    private _unsubscribeConnectionsHandler;
-    constructor(roomName: string, defaultValue: T, mode?: RoomSubscriptionMode);
-    get(): Snapshot<T>;
-    subscribe(set: (value: Snapshot<T>) => void): () => void;
-    onJoin(client: KokimokiClient<any>): Promise<void>;
-    onBeforeLeave(client: KokimokiClient): Promise<void>;
-    onLeave(client: KokimokiClient): Promise<void>;
-}