@kokimoki/kit 1.0.3 → 1.3.0

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./kokimoki-kit-plugin";
 export * from "./preprocess-style";
+export * from "./schema-builder";

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./kokimoki-kit-plugin"), exports);
 __exportStar(require("./preprocess-style"), exports);
+__exportStar(require("./schema-builder"), exports);

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

@@ -1,2 +1,12 @@
 import type { Plugin } from "vite";
-export declare const kokimokiKitPlugin: () => Plugin;
+import type { Form } from "./schema-builder";
+export interface KokimokiKitConfig {
+    conceptId: string;
+    form: Form<any, any>;
+    deployCodes: {
+        name: string;
+        description: string;
+        clientContext: any;
+    }[];
+}
+export declare function kokimokiKitPlugin(config: KokimokiKitConfig): Plugin;

package/dist/kokimoki-kit-plugin.js

@@ -7,7 +7,8 @@ exports.kokimokiKitPlugin = void 0;
 const bson_objectid_1 = __importDefault(require("bson-objectid"));
 const promises_1 = __importDefault(require("fs/promises"));
 const preprocess_style_1 = require("./preprocess-style");
-const kokimokiKitPlugin = () => {
+const version_1 = require("./version");
+function kokimokiKitPlugin(config) {
     return {
         name: "kokimoki-kit",
         async transform(code, id) {
@@ -36,7 +37,13 @@ const kokimokiKitPlugin = () => {
               }
               </script>
               <script>
-                window.__toAssetsUrl = (path) => "%KM_ASSETS%/" + path;
+                window.__toAssetsUrl = (path) => {
+                  if (path.startsWith("km-proxy")) {
+                    return "/%KM_BUILD_ID%/" + path;
+                  }
+
+                  return "%KM_ASSETS%/" + path;
+                };
               </script>
             `)
                     .replace(/<link.*?href="(.*?)".*?>/g, (match, p1) => {
@@ -80,12 +87,29 @@ const kokimokiKitPlugin = () => {
             "test": true,
             "host": "y-wss.kokimoki.com",
             "appId": "${appId}",
+            "configObject": ${JSON.stringify(config.form.value)},
             "base": "/",
             "assets": "/"
           }
           </script>`);
             return html;
         },
+        // write kokimoki metadata to .kokimoki directory
+        async generateBundle(_, _bundle) {
+            // write config
+            await promises_1.default.writeFile(".kokimoki/config.json", JSON.stringify({
+                kokimokiKitVersion: version_1.KOKIMOKI_KIT_VERSION,
+                conceptId: config.conceptId,
+                deployCodes: config.deployCodes,
+                build: "dist",
+            }, null, 2));
+            // write schema
+            const schema = JSON.stringify(config.form.schema, null, 2);
+            await promises_1.default.writeFile(".kokimoki/schema.json", schema);
+            // write scheme defaults
+            const defaultValue = JSON.stringify(config.form.value, null, 2);
+            await promises_1.default.writeFile(".kokimoki/schema-defaults.json", defaultValue);
+        },
     };
-};
+}
 exports.kokimokiKitPlugin = kokimokiKitPlugin;

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

@@ -0,0 +1 @@
+export declare const KOKIMOKI_KIT_VERSION = "1.3.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kokimoki/kit",
-  "version": "1.0.3",
+  "version": "1.3.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,7 @@
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
+    "prebuild": "node -p \"'export const KOKIMOKI_KIT_VERSION = ' + JSON.stringify(require('./package.json').version) + ';'\" > src/version.ts",
     "build": "tsc"
   },
   "author": "Loquiz OÜ",