@kokimoki/app 1.13.0 → 1.15.0

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_APP_VERSION = "1.13.0";
+export declare const KOKIMOKI_APP_VERSION = "1.15.0";

package/dist/version.js

@@ -1 +1 @@
-export const KOKIMOKI_APP_VERSION = "1.13.0";
+export const KOKIMOKI_APP_VERSION = "1.15.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/app",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "type": "module",
   "description": "Kokimoki app",
   "main": "dist/index.js",
@@ -35,7 +35,8 @@
     "events": "^3.3.0",
     "farmhash-modern": "^1.1.0",
     "typed-emitter": "^2.1.0",
-    "valtio": "^1.13.1",
-    "valtio-yjs": "^0.5.1"
+    "valtio": "^2.1.5",
+    "valtio-yjs": "^0.6.0",
+    "yjs": "^13.6.27"
   }
 }

package/dist/fields.d.ts

@@ -1,95 +0,0 @@
-export interface FieldOptions {
-    label?: string;
-}
-export declare abstract class Field<T> {
-    readonly options: FieldOptions;
-    constructor(options: FieldOptions);
-    abstract get value(): T;
-    abstract get schema(): any;
-}
-export declare class BooleanField extends Field<boolean> {
-    value: boolean;
-    constructor(value: boolean, options?: FieldOptions);
-    get schema(): {
-        type: string;
-        default: boolean;
-    };
-}
-export declare class ConstField<T extends string> extends Field<string extends T ? never : T> {
-    value: string extends T ? never : T;
-    constructor(value: string extends T ? never : T, options?: FieldOptions);
-    get schema(): {
-        const: string extends T ? never : T;
-    };
-}
-export declare class ImageField extends Field<string> {
-    value: string;
-    constructor(value: string, options?: FieldOptions);
-    get schema(): {
-        type: string;
-        default: string;
-    };
-}
-export declare class TextField extends Field<string> {
-    value: string;
-    constructor(value: string, options?: FieldOptions);
-    get schema(): {
-        type: string;
-        default: string;
-    };
-}
-export declare class EnumField<T extends Record<string, string>> extends Field<keyof T> {
-    enumValues: T;
-    value: keyof T;
-    constructor(enumValues: T, value: keyof T, options?: FieldOptions);
-    get schema(): {
-        enum: string[];
-    };
-}
-export declare class IntegerField extends Field<number> {
-    value: number;
-    constructor(value: number, options?: FieldOptions);
-    get schema(): {
-        type: string;
-        default: number;
-    };
-}
-export declare class FloatField extends Field<number> {
-    value: number;
-    constructor(value: number, options?: FieldOptions);
-    get schema(): {
-        type: string;
-        default: number;
-    };
-}
-export declare class FormGroup<T extends Record<string, Field<any>>, O extends Record<string, Field<any>>> extends Field<{
-    [key in keyof T]: T[key]["value"];
-} & Partial<{
-    [key in keyof O]: O[key]["value"];
-}>> {
-    requiredFields: T;
-    optionalFields: O;
-    constructor(requiredFields: T, optionalFields?: O, options?: FieldOptions);
-    get value(): {
-        [key in keyof T]: T[key]["value"];
-    } & Partial<{
-        [key in keyof O]: O[key]["value"];
-    }>;
-    get schema(): {
-        type: string;
-        properties: any;
-        required: string[];
-    };
-}
-export declare class FormArray<T> extends Field<T[]> {
-    private factory;
-    value: Field<T>["value"][];
-    constructor(factory: () => Field<T>, value: Field<T>["value"][], options?: FieldOptions);
-    get schema(): {
-        type: string;
-        items: any;
-        default: T[];
-    };
-}
-export declare class Form<R extends Record<string, Field<any>>, O extends Record<string, Field<any>>> extends FormGroup<R, O> {
-}

package/dist/fields.js

@@ -1,152 +0,0 @@
-const defaultFieldOptions = {};
-export class Field {
-    options;
-    constructor(options) {
-        this.options = options;
-    }
-}
-export class BooleanField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            type: "boolean",
-            default: this.value,
-        };
-    }
-}
-export class ConstField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            const: this.value,
-        };
-    }
-}
-export class ImageField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            type: "string",
-            default: this.value,
-        };
-    }
-}
-export class TextField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            type: "string",
-            default: this.value,
-        };
-    }
-}
-export class EnumField extends Field {
-    enumValues;
-    value;
-    constructor(enumValues, value, options = defaultFieldOptions) {
-        super(options);
-        this.enumValues = enumValues;
-        this.value = value;
-    }
-    get schema() {
-        return {
-            enum: Object.keys(this.enumValues),
-        };
-    }
-}
-export class IntegerField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            type: "integer",
-            default: this.value,
-        };
-    }
-}
-export class FloatField extends Field {
-    value;
-    constructor(value, options = defaultFieldOptions) {
-        super(options);
-        this.value = value;
-    }
-    get schema() {
-        return {
-            type: "number",
-            default: this.value,
-        };
-    }
-}
-export class FormGroup extends Field {
-    requiredFields;
-    optionalFields;
-    constructor(requiredFields, optionalFields = {}, options = defaultFieldOptions) {
-        super(options);
-        this.requiredFields = requiredFields;
-        this.optionalFields = optionalFields;
-    }
-    get value() {
-        const value = Object.entries(this.requiredFields).reduce((acc, [key, field]) => {
-            acc[key] = field.value;
-            return acc;
-        }, {});
-        Object.entries(this.optionalFields).forEach(([key, field]) => {
-            if (field.value !== undefined) {
-                value[key] = field.value;
-            }
-        });
-        return value;
-    }
-    get schema() {
-        const properties = {};
-        Object.entries(this.requiredFields).forEach(([key, field]) => {
-            properties[key] = field.schema;
-        });
-        Object.entries(this.optionalFields).forEach(([key, field]) => {
-            properties[key] = field.schema;
-        });
-        return {
-            type: "object",
-            properties,
-            required: Object.keys(this.requiredFields),
-        };
-    }
-}
-export class FormArray extends Field {
-    factory;
-    value;
-    constructor(factory, value, options = defaultFieldOptions) {
-        super(options);
-        this.factory = factory;
-        this.value = value;
-    }
-    get schema() {
-        const field = this.factory();
-        return {
-            type: "array",
-            items: field.schema,
-            default: this.value,
-        };
-    }
-}
-export class Form extends FormGroup {
-}

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 = {}));