@kokimoki/kit 1.6.4 → 1.6.6

package/dist/kokimoki-kit-plugin.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "vite";
+import type { PluginOption } from "vite";
 import { ZodType } from "zod/v4";
 export interface KokimokiKitConfig {
     conceptId: string;
@@ -11,4 +11,4 @@ export interface KokimokiKitConfig {
     defaultProjectConfigPath: string;
     defaultProjectStylePath?: string;
 }
-export declare function kokimokiKitPlugin(config: KokimokiKitConfig): Plugin;
+export declare function kokimokiKitPlugin(config: KokimokiKitConfig): PluginOption;

package/dist/kokimoki-kit-plugin.js

@@ -133,6 +133,16 @@ function kokimokiKitPlugin(config) {
         },
         // write kokimoki metadata to .kokimoki directory
         async generateBundle(_, _bundle) {
+            // Ensure .kokimoki directory exists
+            try {
+                await promises_1.default.mkdir(".kokimoki");
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e?.code !== "EEXIST") {
+                    throw e;
+                }
+            }
             // write config
             await promises_1.default.writeFile(".kokimoki/config.json", JSON.stringify({
                 kokimokiKitVersion: version_1.KOKIMOKI_KIT_VERSION,

package/dist/schema-builder.d.ts

@@ -0,0 +1,95 @@
+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/schema-builder.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Form = exports.FormArray = exports.FormGroup = exports.FloatField = exports.IntegerField = exports.EnumField = exports.TextField = exports.ImageField = exports.ConstField = exports.BooleanField = exports.Field = void 0;
+const defaultFieldOptions = {};
+class Field {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+}
+exports.Field = Field;
+class BooleanField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "boolean",
+            default: this.value,
+        };
+    }
+}
+exports.BooleanField = BooleanField;
+class ConstField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            const: this.value,
+        };
+    }
+}
+exports.ConstField = ConstField;
+class ImageField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "string",
+            default: this.value,
+        };
+    }
+}
+exports.ImageField = ImageField;
+class TextField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "string",
+            default: this.value,
+        };
+    }
+}
+exports.TextField = TextField;
+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),
+        };
+    }
+}
+exports.EnumField = EnumField;
+class IntegerField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "integer",
+            default: this.value,
+        };
+    }
+}
+exports.IntegerField = IntegerField;
+class FloatField extends Field {
+    value;
+    constructor(value, options = defaultFieldOptions) {
+        super(options);
+        this.value = value;
+    }
+    get schema() {
+        return {
+            type: "number",
+            default: this.value,
+        };
+    }
+}
+exports.FloatField = FloatField;
+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),
+        };
+    }
+}
+exports.FormGroup = FormGroup;
+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,
+        };
+    }
+}
+exports.FormArray = FormArray;
+class Form extends FormGroup {
+}
+exports.Form = Form;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const KOKIMOKI_KIT_VERSION = "1.6.4";
+export declare const KOKIMOKI_KIT_VERSION = "1.6.6";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KOKIMOKI_KIT_VERSION = void 0;
-exports.KOKIMOKI_KIT_VERSION = "1.6.4";
+exports.KOKIMOKI_KIT_VERSION = "1.6.6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/kit",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,7 @@
     "@types/colornames": "^1.1.4",
     "@types/expect": "^24.3.2",
     "mocha": "^11.1.0",
-    "ts-mocha": "^10.0.0",
-    "vite": "^5.4.8"
+    "ts-mocha": "^10.0.0"
   },
   "dependencies": {
     "bson-objectid": "^2.0.4",
@@ -29,6 +28,6 @@
     "zod": "^3.25.30"
   },
   "peerDependencies": {
-    "vite": ">=5"
+    "vite": ">=4 <=6"
   }
 }