@kokimoki/app 1.15.0 → 1.15.1

package/dist/kokimoki-schema.d.ts

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

@@ -0,0 +1,163 @@
+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-store.js

@@ -1,5 +1,5 @@
 import * as Y from "yjs";
-import { proxy as yjsProxy } from "valtio";
+import { proxy as yjsProxy } from "valtio/vanilla";
 import { bind as yjsBind } from "valtio-yjs";
 import { RoomSubscriptionMode } from "./room-subscription-mode";
 export class KokimokiStore {

package/dist/kokimoki-transaction.js

@@ -1,5 +1,5 @@
 import * as Y from "yjs";
-import { proxy as yjsProxy } from "valtio";
+import { proxy as yjsProxy } from "valtio/vanilla";
 import { bind as yjsBind } from "valtio-yjs";
 export class KokimokiTransaction {
     // private _clones = new Map<

package/dist/kokimoki.min.js

@@ -486,7 +486,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 var eventsExports = events.exports;
 var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
 
-const KOKIMOKI_APP_VERSION = "1.15.0";
+const KOKIMOKI_APP_VERSION = "1.15.1";
 
 /**
  * Utility module to work with key-value stores.