@skalfa/skalfa-app-core 1.0.0

package/dist/commands/blueprint.js

@@ -0,0 +1,306 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "./logger";
+import { conversion } from "../conversion.util";
+const renderJS = (value, indent = 0) => {
+    const pad = " ".repeat(indent);
+    if (Array.isArray(value)) {
+        if (!value.length)
+            return "[]";
+        if (value.every(v => typeof v === "string")) {
+            return `[${value.map(v => JSON.stringify(v)).join(", ")}]`;
+        }
+        return `[\n${value
+            .map(v => pad + "  " + renderJS(v, indent + 2))
+            .join(",\n")}\n${pad}]`;
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value);
+        if (!entries.length)
+            return "{}";
+        return `{\n${entries
+            .map(([k, v]) => `${pad}  ${k}: ${renderJS(v, indent + 2)}`)
+            .join(",\n")}\n${pad}}`;
+    }
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    return String(value);
+};
+function extractValidationArray(def = "") {
+    const rules = [];
+    if (def.includes("required"))
+        rules.push("required");
+    if (def.includes("email"))
+        rules.push("email");
+    if (def.includes("url"))
+        rules.push("url");
+    const min = def.match(/min,(\d+)/);
+    if (min)
+        rules.push(`min:${min[1]}`);
+    const max = def.match(/max,(\d+)/);
+    if (max)
+        rules.push(`max:${max[1]}`);
+    return rules;
+}
+function extractFormType(rules) {
+    const rule = rules.find(r => r.startsWith("form:"));
+    return rule ? rule.replace("form:", "") : undefined;
+}
+function inferFormType(pageDef = "", modelDef = "") {
+    const explicit = pageDef.split("|");
+    if (explicit && explicit[0] && explicit[0] != "text")
+        return explicit[0];
+    if (modelDef.includes("type:integer") || modelDef.includes("type:float")) {
+        return "number";
+    }
+    if (modelDef.includes("type:date"))
+        return "date";
+    if (modelDef.includes("type:datetime"))
+        return "datetime";
+    if (modelDef.includes("type:image"))
+        return "image";
+    return "default";
+}
+function parseFeatures(features) {
+    const controlBar = [];
+    const action = [];
+    if (!features) {
+        return { controlBar: ["CREATE"], action: ["EDIT", "DELETE"] };
+    }
+    const list = features.split(" ");
+    if (list.includes("create"))
+        controlBar.push("CREATE");
+    controlBar.push("SEARCH", "SORT", "SELECTABLE");
+    if (list.includes("import"))
+        controlBar.push("IMPORT");
+    if (list.includes("export"))
+        controlBar.push("EXPORT");
+    if (list.includes("print"))
+        controlBar.push("PRINT");
+    if (list.includes("update") || list.includes("edit"))
+        action.push("EDIT");
+    if (list.includes("delete"))
+        action.push("DELETE");
+    if (list.includes("detail"))
+        action.push("DETAIL");
+    return { controlBar, action };
+}
+function parseModelSchema(schema = {}) {
+    const columns = [];
+    const forms = [];
+    const details = [];
+    for (const [field, def] of Object.entries(schema)) {
+        const label = conversion.strPascal(field, " ");
+        if (def.includes("selectable")) {
+            columns.push({ selector: field, label });
+            details.push({ label, item: field });
+        }
+        if (def.includes("fillable")) {
+            const fieldType = inferFormType("", def);
+            forms.push({
+                ...(fieldType != "default" ? { type: fieldType } : {}),
+                construction: {
+                    name: field,
+                    label,
+                    placeholder: "Masukkan " + label.toLowerCase(),
+                    validations: extractValidationArray(def)
+                }
+            });
+        }
+    }
+    return { columns, forms, details };
+}
+function resolvePath(page, controllers, model) {
+    if (page.path)
+        return page.path;
+    if (Array.isArray(controllers)) {
+        const match = controllers;
+        if (match)
+            return "/" + match[1];
+    }
+    return "/" + model.split("/").pop();
+}
+function parsePageSchema(pageSchema, modelSchema = {}) {
+    const columns = [];
+    const forms = [];
+    const details = [];
+    for (const [field, def] of Object.entries(pageSchema)) {
+        const rules = def.replace(/\|/g, " ").split(" ").filter(Boolean);
+        const defaultLabel = conversion.strPascal(field, " ");
+        const colLabelRule = rules.find(r => r.includes("column:label,"));
+        const colLabel = conversion.strPascal(colLabelRule ? colLabelRule.split(",")[1] : defaultLabel, " ");
+        const formLabelRule = rules.find(r => r.includes("form:label,"));
+        const formLabel = conversion.strPascal(formLabelRule ? formLabelRule.split(",")[1] : (colLabelRule ? colLabel : defaultLabel), " ");
+        const detailLabel = colLabelRule ? colLabel : (formLabelRule ? formLabel : defaultLabel);
+        const hasColumn = rules.some(r => r.includes("column:"));
+        const hasForm = rules.some(r => r.includes("form:")) || rules.every(r => !r.includes("column:"));
+        const hasDetail = rules.includes("detail");
+        if (hasColumn) {
+            columns.push({
+                selector: field,
+                label: colLabel,
+                ...(rules.includes("column:sortable") || rules.includes("sortable") ? { sortable: true } : {})
+            });
+            if (!hasDetail)
+                details.push({ label: detailLabel, item: field });
+        }
+        if (hasForm) {
+            const typeRules = rules.filter(r => !r.startsWith("form:label,"));
+            const typeRule = extractFormType(typeRules);
+            let fieldType = inferFormType(typeRule, modelSchema[field] || "");
+            let selectPath = "";
+            const selectRule = rules.find(r => r.startsWith("select,") || r.startsWith("form:select,"));
+            if (selectRule) {
+                fieldType = "select";
+                selectPath = selectRule.split(",")[1];
+            }
+            if (typeRule === "check")
+                fieldType = "boolean";
+            if (typeRule === "currency")
+                fieldType = "currency";
+            if (typeRule === "image")
+                fieldType = "image";
+            if (typeRule === "date")
+                fieldType = "date";
+            if (typeRule === "time")
+                fieldType = "time";
+            let col;
+            const colRule = rules.find(r => /col,(\d+)/.test(r));
+            if (colRule) {
+                const n = Number(colRule.split(',').pop());
+                if (n >= 1 && n <= 12)
+                    col = n;
+            }
+            forms.push({
+                ...(fieldType != "default" && fieldType != "text" ? { type: fieldType } : {}),
+                ...(col ? { col } : {}),
+                construction: {
+                    name: field,
+                    label: formLabel,
+                    placeholder: "Masukkan " + formLabel.toLowerCase(),
+                    validations: extractValidationArray(modelSchema[field] || ""),
+                    ...(selectPath ? { serverOptionControl: { path: selectPath } } : {}),
+                    ...(rules.includes("wrap") ? { wrap: true } : {})
+                }
+            });
+        }
+        if (hasDetail)
+            details.push({ label: detailLabel, item: field });
+    }
+    const formMap = new Map();
+    forms.forEach(f => formMap.set(f.construction.name, f));
+    const nestedForms = [];
+    forms.forEach(f => {
+        const name = f.construction.name;
+        if (name.includes(".")) {
+            const parts = name.split(".");
+            const selfName = parts.pop();
+            const parentName = parts.join(".");
+            const parent = formMap.get(parentName);
+            if (parent) {
+                if (!parent.type)
+                    parent.type = "cluster";
+                if (!parent.construction.fields)
+                    parent.construction.fields = [];
+                f.construction.name = selfName;
+                parent.construction.fields.push(f);
+            }
+            else {
+                nestedForms.push(f);
+            }
+        }
+        else {
+            nestedForms.push(f);
+        }
+    });
+    return { columns, forms: nestedForms, details };
+}
+function loadBlueprintFiles(dir = "blueprints") {
+    const basePath = path.join(process.cwd(), dir);
+    if (!fs.existsSync(basePath)) {
+        throw new Error("Blueprint folder not found");
+    }
+    return fs.readdirSync(basePath)
+        .filter(f => f.endsWith(".blueprint.json"))
+        .map(file => {
+        const fullPath = path.join(basePath, file);
+        const content = JSON.parse(fs.readFileSync(fullPath, "utf-8"));
+        if (!Array.isArray(content)) {
+            throw new Error(`${file} must export array of blueprints`);
+        }
+        return {
+            file: file.replace(".blueprint.json", ""),
+            blueprints: content,
+        };
+    });
+}
+const blueprintMarker = `// ============================================
+// ## file THIS FILE IS AUTO-GENERATED BY BLUEPRINT
+// ?? Blueprint : {{ blueprint }}
+// !! If this comment is removed, blueprint engine WILL NOT override this file.
+// ============================================
+
+
+`;
+// ===============================
+// ## Main generator
+// ===============================
+export async function blueprint(options) {
+    const stub = fs.readFileSync(path.join(process.cwd(), "/utils/commands/stubs/table-blueprint.stub"), "utf-8");
+    const loaded = loadBlueprintFiles();
+    for (const file of loaded) {
+        for (const bp of file.blueprints) {
+            const pagesToGenerate = { ...(bp.pages || {}) };
+            for (const [key, val] of Object.entries(bp)) {
+                if (typeof val === "object" && val["schema"]) {
+                    pagesToGenerate[key] = val;
+                }
+            }
+            for (const [key, page] of Object.entries(pagesToGenerate)) {
+                const route = key;
+                const name = conversion.strPascal(route.split("/").pop());
+                if (options?.only && !options.only.includes(name))
+                    continue;
+                const outDir = path.join(process.cwd(), "app", route);
+                fs.mkdirSync(outDir, { recursive: true });
+                const filePath = path.join(outDir, "page.tsx");
+                if (fs.existsSync(filePath)) {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    if (!content.includes("AUTO-GENERATED BY BLUEPRINT")) {
+                        logger.info(`Skip overridden file: ${filePath}`);
+                        continue;
+                    }
+                }
+                const schema = bp.schema ?? {};
+                const parsed = page?.schema ? parsePageSchema(page.schema, schema) : parseModelSchema(schema);
+                const { controlBar, action } = parseFeatures(page?.features);
+                const fetchPath = resolvePath(page, bp.controllers, bp.model);
+                let properties = `
+        fetchControl={{
+          path: "${fetchPath}" 
+        }}
+          columnControl={${renderJS(parsed.columns, 8)}}
+          formControl={{ 
+            fields: ${renderJS(parsed.forms, 10)} 
+          }}
+        `;
+                if (parsed.details) {
+                    properties += `  detailControl={${renderJS(parsed.details, 8)}}\n`;
+                }
+                if (controlBar.length) {
+                    properties += `        controlBar={${JSON.stringify(controlBar)}}\n`;
+                }
+                if (action.length) {
+                    properties += `        actionControl={${JSON.stringify(action)}}\n`;
+                }
+                const content = stub
+                    .replace(/{{ marker }}/g, blueprintMarker.replace(/{{ blueprint }}/g, file.file + ".blueprint.json"))
+                    .replace(/{{ name }}/g, name)
+                    .replace(/{{ title }}/g, name)
+                    .replace(/{{ properties }}/g, properties);
+                fs.writeFileSync(path.join(outDir, "page.tsx"), content);
+                logger.info(`Generated: ${filePath}`);
+            }
+        }
+    }
+}

package/dist/commands/light.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/light.js

@@ -0,0 +1,16 @@
+import { Command } from "commander";
+import { usePdf } from "./use-pdf";
+import { blueprint } from "./blueprint";
+import { logger } from "./logger";
+const program = new Command();
+program.name("light").description("Next Light CLI").version("1.0.0");
+program.command("use-pdf").description("Copy pdf.worker.min.mjs ke folder public/").action(usePdf);
+program.command("blueprint")
+    .option("-o, --only <names...>", "Run only specific blueprints")
+    .description("Generate blueprint")
+    .action(async (opts) => {
+    await blueprint({ only: opts.only });
+    logger.info("Success run all blueprints!");
+    process.exit(0);
+});
+program.parse();

package/dist/commands/logger.d.ts

@@ -0,0 +1,10 @@
+export declare const logger: {
+    start: (...msg: unknown[]) => void;
+    info: (...msg: unknown[]) => void;
+    error: (...msg: unknown[]) => void;
+    warning: (...msg: unknown[]) => void;
+    cavity: (...msg: unknown[]) => void;
+    cavityError: (...msg: unknown[]) => void;
+    socket: (...msg: unknown[]) => void;
+    socketError: (...msg: unknown[]) => void;
+};

package/dist/commands/logger.js

@@ -0,0 +1,36 @@
+const colors = {
+    default: "\x1b[0m", // default
+    start: "\x1b[32m", // green
+    info: "\x1b[36m", // cyan
+    error: "\x1b[31m", // red
+    warning: "\x1b[33m", // yellow
+    cavity: "\x1b[34m", // blue
+    cavityError: "\x1b[31m", // red
+    socket: "\x1b[35m", // magenta
+    socketError: "\x1b[31m", // red
+};
+const prefixes = {
+    start: "START",
+    info: "INFO",
+    error: "ERROR",
+    warning: "WARNING",
+    cavity: "CAVITY",
+    socket: "SOCKET",
+    cavityError: "CAVITY ERROR",
+    socketError: "SOCKET ERROR",
+};
+function log(type, ...msg) {
+    const color = colors[type];
+    const prefix = prefixes[type];
+    console.log(`${color}[${prefix}]${colors.default}`, ...msg);
+}
+export const logger = {
+    start: (...msg) => log("start", ...msg),
+    info: (...msg) => log("info", ...msg),
+    error: (...msg) => log("error", ...msg),
+    warning: (...msg) => log("warning", ...msg),
+    cavity: (...msg) => log("cavity", ...msg),
+    cavityError: (...msg) => log("cavityError", ...msg),
+    socket: (...msg) => log("socket", ...msg),
+    socketError: (...msg) => log("socketError", ...msg),
+};

package/dist/commands/use-pdf.d.ts

@@ -0,0 +1 @@
+export declare function usePdf(): void;

package/dist/commands/use-pdf.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { logger } from "./logger";
+export function usePdf() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const projectRoot = path.join(__dirname, "..", "..");
+    const source = path.join(projectRoot, "node_modules", "pdfjs-dist", "legacy", "build", "pdf.worker.min.mjs");
+    const target = path.join(projectRoot, "public", "pdf.worker.min.mjs");
+    if (!fs.existsSync(source)) {
+        logger.error(`Gagal: pdf.worker.min.mjs tidak ditemukan.`);
+        process.exit(1);
+    }
+    fs.copyFileSync(source, target);
+    logger.info("Berhasil memindahkan worker ke public/pdf.worker.min.mjs");
+}

package/dist/conversion.util.d.ts

@@ -0,0 +1,10 @@
+export declare const conversion: {
+    strSnake(value: string, delimiter?: string): string;
+    strSlug(value: string, delimiter?: string): string;
+    strCamel(value: string, delimiter?: string): string;
+    strPascal(value: string, delimiter?: string): string;
+    strPlural(value: string): string;
+    strSingular(value: string): string;
+    currency: (value: number, locale?: string, currency?: string) => string;
+    date: (date: string, format?: string) => string;
+};

package/dist/conversion.util.js

@@ -0,0 +1,53 @@
+import moment from "moment";
+export const conversion = {
+    // =============================>
+    // ## Conversion: String formatter 
+    // =============================>
+    strSnake(value, delimiter = "_") {
+        return toWords(value).join(delimiter);
+    },
+    strSlug(value, delimiter = "-") {
+        return toWords(value).join(delimiter);
+    },
+    strCamel(value, delimiter = "") {
+        return toWords(value).map((w, i) => i === 0 ? w : w[0].toUpperCase() + w.slice(1)).join(delimiter);
+    },
+    strPascal(value, delimiter = "") {
+        return toWords(value).map(w => w[0].toUpperCase() + w.slice(1)).join(delimiter);
+    },
+    strPlural(value) {
+        const match = value.match(/^(.*?)([A-Za-z]+)$/);
+        if (!match)
+            return value;
+        const [, prefix, word] = match;
+        if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
+            return prefix + word.slice(0, -1) + "ies";
+        }
+        if (!word.endsWith("s"))
+            return prefix + word + "s";
+        return value;
+    },
+    strSingular(value) {
+        return value
+            .replace(/[-_]/g, " ")
+            .replace(/\b\w/g, (l) => l.toUpperCase())
+            .replace(/\s+/g, "");
+    },
+    // ==============================> 
+    // ## currency formatter 
+    // ==============================> 
+    currency: (value, locale = "id-ID", currency = "IDR") => { const val = Math.trunc(value); return new Intl.NumberFormat(locale, { style: "currency", currency, minimumFractionDigits: 0, maximumFractionDigits: 2 }).format(val); },
+    // ==============================> 
+    // ## date formatter 
+    // ==============================> 
+    date: (date, format = "DD MMM YYYY") => moment(date).format(format),
+};
+function toWords(value) {
+    return value
+        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+        .replace(/[_\-\s]+/g, " ")
+        .trim()
+        .toLowerCase()
+        .split(" ")
+        .filter(Boolean);
+}

package/dist/encryption.util.d.ts

@@ -0,0 +1,6 @@
+type AlgorithmType = "AES" | "TripleDES" | "SHA256" | "SHA512" | "MD5";
+export declare const encryption: {
+    set: (data: any, key?: string, algorithm?: AlgorithmType) => string;
+    get: (data: string, key?: string, algorithm?: AlgorithmType) => any;
+};
+export {};

package/dist/encryption.util.js

@@ -0,0 +1,56 @@
+import CryptoJS from "crypto-js";
+export const encryption = {
+    // ==============================>
+    // ## Encryption data 
+    // ==============================>
+    set: (data, key = process.env.NEXT_PUBLIC_APP_KEY || "", algorithm = "AES") => {
+        const text = typeof data === "string" ? data : JSON.stringify(data);
+        let encrypted;
+        switch (algorithm) {
+            case "AES":
+                encrypted = CryptoJS.AES.encrypt(text, key).toString();
+                break;
+            case "TripleDES":
+                encrypted = CryptoJS.TripleDES.encrypt(text, key).toString();
+                break;
+            case "SHA256":
+                encrypted = CryptoJS.SHA256(text).toString(CryptoJS.enc.Hex);
+                break;
+            case "SHA512":
+                encrypted = CryptoJS.SHA512(text).toString(CryptoJS.enc.Hex);
+                break;
+            case "MD5":
+                encrypted = CryptoJS.MD5(text).toString(CryptoJS.enc.Hex);
+                break;
+            default: throw new Error(`Unsupported algorithm: ${algorithm}`);
+        }
+        if (["SHA256", "SHA512", "MD5"].includes(algorithm))
+            return encrypted;
+        const encData = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(encrypted));
+        return encData;
+    },
+    // ==============================>
+    // ## Decryption data 
+    // ==============================>
+    get: (data, key = process.env.NEXT_PUBLIC_APP_KEY || "", algorithm = "AES") => {
+        if (["SHA256", "SHA512", "MD5"].includes(algorithm))
+            throw new Error(`${algorithm} is a one-way hash and cannot be decrypted.`);
+        const decData = CryptoJS.enc.Base64.parse(data).toString(CryptoJS.enc.Utf8);
+        let decrypted;
+        switch (algorithm) {
+            case "AES":
+                decrypted = CryptoJS.AES.decrypt(decData, key).toString(CryptoJS.enc.Utf8);
+                break;
+            case "TripleDES":
+                decrypted = CryptoJS.TripleDES.decrypt(decData, key).toString(CryptoJS.enc.Utf8);
+                break;
+            default: throw new Error(`Unsupported algorithm: ${algorithm}`);
+        }
+        try {
+            return JSON.parse(decrypted);
+        }
+        catch {
+            return decrypted;
+        }
+    }
+};

package/dist/form.util.d.ts

@@ -0,0 +1,87 @@
+import { ValidationRules } from "./validation.util";
+import { ApiType } from "./api.util";
+type DBSchema = any;
+export interface FormRegisterType {
+    name: string;
+    status?: boolean;
+    validations?: ValidationRules;
+}
+export interface FormValueType {
+    name: string;
+    value?: any;
+}
+export interface FormErrorType {
+    name: string;
+    error?: string | null;
+}
+export interface FormStateType {
+    formRegisters: FormRegisterType[];
+    formValues: FormValueType[];
+    formErrors: FormErrorType[];
+    loading: boolean;
+    showConfirm: boolean;
+}
+type ActionPayloadType = {
+    SET_REGISTER: FormRegisterType;
+    UNREGISTER: string;
+    UNREGISTER_PREFIX: string;
+    SET_VALUES: FormValueType[];
+    SET_VALUE: FormValueType;
+    SET_ERRORS: FormErrorType[];
+    SET_LOADING: boolean;
+    SET_CONFIRM: boolean;
+};
+type TypeKeys = keyof ActionPayloadType;
+export type ActionType<T extends TypeKeys = "SET_REGISTER" | "SET_VALUES" | "SET_VALUE" | "SET_ERRORS" | "SET_LOADING" | "SET_CONFIRM" | "RESET" | any> = {
+    type: T;
+    payload?: ActionPayloadType[T];
+};
+export declare const useForm: (submitControl: ((ApiType & {
+    idb?: never;
+}) | {
+    idb: {
+        store: string;
+        schema?: DBSchema;
+    };
+}) & {
+    payload?: ((values: any) => Promise<Record<string, any>> | Record<string, any>) | false;
+    confirmation?: boolean;
+    onSuccess?: (data: any) => void;
+    onFailed?: (code: number) => void;
+}) => {
+    submit: (e: any) => Promise<void>;
+    formControl: (name: string) => {
+        register: (_: string, regValidations?: ValidationRules) => void;
+        unregister: () => void;
+        onChange: (e: any) => void;
+        value: any;
+        invalid: any;
+    };
+    setDefaultValues: (values: Record<string, any> | null) => void;
+    values: FormValueType[] | (FormValueType | {
+        name: any;
+        value: any;
+    })[];
+    setValues: (values: FormValueType[]) => void;
+    errors: any;
+    setErrors: (errors: FormErrorType[]) => void;
+    setRegister: (inputs: FormRegisterType) => void;
+    unregister: (name: string) => void;
+    unregisterPrefix: (prefix: string) => void;
+    loading: any;
+    confirm: {
+        onConfirm: () => Promise<void>;
+        show: any;
+        onClose: () => void;
+    };
+};
+export declare const useInputRandomId: () => string;
+export declare const useInputHandler: (name?: string, value?: any, validations?: ValidationRules, register?: (name: string, validations?: ValidationRules) => void, unregister?: (name: string) => void, isFile?: boolean) => {
+    value: any;
+    setValue: import("react").Dispatch<any>;
+    idle: boolean;
+    setIdle: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    focus: boolean;
+    setFocus: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+};
+export {};