@skalfa/skalfa-app-core 1.0.3 → 1.0.5

package/dist/commands/blueprint.d.ts

@@ -0,0 +1,3 @@
+export declare function blueprint(options?: {
+    only?: string[];
+}): Promise<void>;

package/dist/commands/blueprint.js

@@ -0,0 +1,306 @@
+import fs from "fs";
+import path from "path";
+import { conversion } from "../conversion/conversion";
+import { logger } from "../logger";
+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/cli.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+export declare const usePdfCommand: Command;
+export declare const blueprintCommand: Command;
+export declare const barrelsCommand: Command;
+export declare const watchBarrelsCommand: Command;
+export declare function runCli(): void;

package/dist/commands/cli.js

@@ -0,0 +1,107 @@
+import { Command } from "commander";
+import { usePdf } from "./use-pdf";
+import { blueprint } from "./blueprint";
+import { logger } from "../logger";
+import fs from "fs";
+import path from "path";
+import { exec, execSync } from "child_process";
+// =====================================>
+// ## Command: use-pdf
+// =====================================>
+export const usePdfCommand = new Command("use-pdf")
+    .description("Copy pdf.worker.min.mjs ke folder public/")
+    .action(() => {
+    usePdf();
+});
+// =====================================>
+// ## Command: blueprint
+// =====================================>
+export const blueprintCommand = new Command("blueprint")
+    .description("Generate blueprint")
+    .option("-o, --only <names...>", "Run only specific blueprints")
+    .action(async (opts) => {
+    await blueprint({ only: opts.only });
+    logger.info("Success run all blueprints!");
+    process.exit(0);
+});
+// =====================================>
+// ## Command: barrels (run once)
+// =====================================>
+export const barrelsCommand = new Command("barrels")
+    .description("Generate barrels auto-imports using barrelsby")
+    .action(() => {
+    const rootDir = process.cwd();
+    const configPath = path.join(rootDir, "barrels.json");
+    if (!fs.existsSync(configPath)) {
+        logger.error("barrels.json config file not found at project root");
+        process.exit(1);
+    }
+    logger.info("Generating barrels...");
+    try {
+        execSync("npx barrelsby -c barrels.json", { cwd: rootDir, stdio: "inherit" });
+        logger.info("Barrels successfully generated!");
+        process.exit(0);
+    }
+    catch (err) {
+        logger.error(`Failed to generate barrels: ${err}`);
+        process.exit(1);
+    }
+});
+// =====================================>
+// ## Command: watch:barrels (file watcher)
+// =====================================>
+export const watchBarrelsCommand = new Command("watch:barrels")
+    .description("Watch directories and update barrels automatically on file changes")
+    .action(async () => {
+    const rootDir = process.cwd();
+    const configPath = path.join(rootDir, "barrels.json");
+    if (!fs.existsSync(configPath)) {
+        logger.error("barrels.json config file not found at project root");
+        process.exit(1);
+    }
+    let config = {};
+    try {
+        const configText = fs.readFileSync(configPath, "utf8");
+        config = JSON.parse(configText);
+    }
+    catch (err) {
+        logger.error(`Failed to parse barrels.json: ${err}`);
+        process.exit(1);
+    }
+    const directories = Array.isArray(config.directory) ? config.directory : [config.directory];
+    // Run barrels once at startup
+    logger.info("Initializing barrels generation...");
+    try {
+        execSync("npx barrelsby -c barrels.json", { cwd: rootDir });
+    }
+    catch { }
+    directories.forEach((dir) => {
+        const absoluteDir = path.join(rootDir, dir);
+        if (!fs.existsSync(absoluteDir)) {
+            logger.error(`Barrels error: ${absoluteDir} directory not found`);
+            return;
+        }
+        fs.watch(absoluteDir, { recursive: true }, (_, filename) => {
+            if (filename && (filename.endsWith(".ts") || filename.endsWith(".tsx")) && filename !== "index.ts") {
+                exec("npx barrelsby -c barrels.json", { cwd: rootDir }, (error) => {
+                    if (error) {
+                        logger.error(`Failed to update barrels for ${dir}: ${error.message}`);
+                    }
+                    else {
+                        logger.info(`Barrels updated: ${path.join(dir, "index.ts")}`);
+                    }
+                });
+            }
+        });
+    });
+    logger.start("Barrels watcher running for: " + directories.join(", "));
+});
+export function runCli() {
+    const program = new Command();
+    program.name("skalfa").description("Skalfa-app CLI").version("1.0.0");
+    program.addCommand(usePdfCommand);
+    program.addCommand(blueprintCommand);
+    program.addCommand(barrelsCommand);
+    program.addCommand(watchBarrelsCommand);
+    program.parse(process.argv);
+}

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/hooks.d.ts

@@ -0,0 +1,14 @@
+export declare const useResponsive: () => {
+    isXs: boolean;
+    isSm: boolean;
+    isMd: boolean;
+    isLg: boolean;
+    isXl: boolean;
+    isMobile: boolean;
+    isTablet: boolean;
+    isDesktop: boolean;
+    width: number;
+    height: number;
+};
+export declare function useKeyboardOpen(): boolean;
+export declare const useLazySearch: (keyword: string) => string[];

package/dist/hooks.js

@@ -0,0 +1,63 @@
+"use client";
+import { useEffect, useState } from "react";
+// ==============================>
+// ## Detect device size
+// ==============================>
+export const useResponsive = () => {
+    const [windowSize, setWindowSize] = useState({ width: 0, height: 0 });
+    useEffect(() => {
+        if (typeof window === "undefined")
+            return;
+        const handleResize = () => {
+            setWindowSize({ width: window.innerWidth, height: window.innerHeight });
+        };
+        handleResize();
+        window.addEventListener("resize", handleResize);
+        return () => window.removeEventListener("resize", handleResize);
+    }, []);
+    return {
+        isXs: windowSize.width < 640,
+        isSm: windowSize.width < 768,
+        isMd: windowSize.width < 1024,
+        isLg: windowSize.width < 1280,
+        isXl: windowSize.width >= 1280,
+        isMobile: windowSize.width < 768,
+        isTablet: windowSize.width >= 768 && windowSize.width < 1024,
+        isDesktop: windowSize.width >= 1024,
+        width: windowSize.width,
+        height: windowSize.height,
+    };
+};
+// ==============================>
+// ## Detect keyboard open
+// ==============================>
+export function useKeyboardOpen() {
+    const [isKeyboardOpen, setIsKeyboardOpen] = useState(false);
+    useEffect(() => {
+        const handleResize = () => {
+            if (window.visualViewport) {
+                const viewportHeight = window.visualViewport.height;
+                const windowHeight = window.innerHeight;
+                setIsKeyboardOpen(viewportHeight < windowHeight);
+            }
+        };
+        window.visualViewport?.addEventListener("resize", handleResize);
+        return () => window.visualViewport?.removeEventListener("resize", handleResize);
+    }, []);
+    return isKeyboardOpen;
+}
+// ==============================>
+// ## Search with typing reference
+// ==============================>
+export const useLazySearch = (keyword) => {
+    const [keywordSearch, setKeywordSearch] = useState("");
+    const [doSearch, setDoSearch] = useState(false);
+    useEffect(() => {
+        if (keyword != undefined) {
+            const delaySearch = setTimeout(() => setDoSearch(!doSearch), 500);
+            return () => clearTimeout(delaySearch);
+        }
+    }, [keyword]);
+    useEffect(() => setKeywordSearch(keyword), [doSearch]);
+    return [keywordSearch];
+};

package/dist/index.d.ts

@@ -11,17 +11,5 @@ export * from "./conversion";
 export * from "./shortcut";
 export * from "./logger";
 export * from "./registry";
-export declare const useResponsive: () => {
-    isXs: boolean;
-    isSm: boolean;
-    isMd: boolean;
-    isLg: boolean;
-    isXl: boolean;
-    isMobile: boolean;
-    isTablet: boolean;
-    isDesktop: boolean;
-    width: number;
-    height: number;
-};
-export declare function useKeyboardOpen(): boolean;
-export declare const useLazySearch: (keyword: string) => string[];
+export * from "./commands/cli";
+export * from "./hooks";

package/dist/index.js

@@ -1,5 +1,3 @@
-"use client";
-import { useEffect, useState } from "react";
 // ==============================>
 // ## Export all from core utils
 // ==============================>
@@ -16,64 +14,5 @@ export * from "./conversion";
 export * from "./shortcut";
 export * from "./logger";
 export * from "./registry";
-// ==============================>
-// ## Detect device size
-// ==============================>
-export const useResponsive = () => {
-    const [windowSize, setWindowSize] = useState({ width: 0, height: 0 });
-    useEffect(() => {
-        if (typeof window === "undefined")
-            return;
-        const handleResize = () => {
-            setWindowSize({ width: window.innerWidth, height: window.innerHeight });
-        };
-        handleResize();
-        window.addEventListener("resize", handleResize);
-        return () => window.removeEventListener("resize", handleResize);
-    }, []);
-    return {
-        isXs: windowSize.width < 640,
-        isSm: windowSize.width < 768,
-        isMd: windowSize.width < 1024,
-        isLg: windowSize.width < 1280,
-        isXl: windowSize.width >= 1280,
-        isMobile: windowSize.width < 768,
-        isTablet: windowSize.width >= 768 && windowSize.width < 1024,
-        isDesktop: windowSize.width >= 1024,
-        width: windowSize.width,
-        height: windowSize.height,
-    };
-};
-// ==============================>
-// ## Detect keyboard open
-// ==============================>
-export function useKeyboardOpen() {
-    const [isKeyboardOpen, setIsKeyboardOpen] = useState(false);
-    useEffect(() => {
-        const handleResize = () => {
-            if (window.visualViewport) {
-                const viewportHeight = window.visualViewport.height;
-                const windowHeight = window.innerHeight;
-                setIsKeyboardOpen(viewportHeight < windowHeight);
-            }
-        };
-        window.visualViewport?.addEventListener("resize", handleResize);
-        return () => window.visualViewport?.removeEventListener("resize", handleResize);
-    }, []);
-    return isKeyboardOpen;
-}
-// ==============================>
-// ## Search with typing reference
-// ==============================>
-export const useLazySearch = (keyword) => {
-    const [keywordSearch, setKeywordSearch] = useState("");
-    const [doSearch, setDoSearch] = useState(false);
-    useEffect(() => {
-        if (keyword != undefined) {
-            const delaySearch = setTimeout(() => setDoSearch(!doSearch), 500);
-            return () => clearTimeout(delaySearch);
-        }
-    }, [keyword]);
-    useEffect(() => setKeywordSearch(keyword), [doSearch]);
-    return [keywordSearch];
-};
+export * from "./commands/cli";
+export * from "./hooks";

package/dist/validation/index.d.ts

@@ -1 +1,2 @@
 export * from "./validation";
+export * from "./use-validation";

package/dist/validation/index.js

@@ -1 +1,2 @@
 export * from "./validation";
+export * from "./use-validation";

package/dist/validation/use-validation.d.ts

@@ -0,0 +1,2 @@
+import { ValidationRules } from "./validation";
+export declare const useValidation: (value?: any, rules?: ValidationRules, includes?: string, sleep?: boolean) => [string, (message: string) => void];

package/dist/validation/use-validation.js

@@ -0,0 +1,23 @@
+"use client";
+import { useEffect, useState } from "react";
+import { validation } from "./validation";
+// =========================>
+// ## Check validation Hook
+// =========================>
+export const useValidation = (value = "", rules = "", includes = "", sleep = false) => {
+    const [message, setMessage] = useState("");
+    useEffect(() => {
+        if (rules && !sleep) {
+            const { valid, message } = validation.check({ value, rules });
+            setMessage(valid ? "" : message);
+        }
+        else {
+            setMessage("");
+        }
+    }, [value, rules, sleep]);
+    useEffect(() => {
+        if (includes)
+            setMessage(includes);
+    }, [includes]);
+    return [message, setMessage];
+};

package/dist/validation/validation.d.ts

@@ -14,5 +14,4 @@ export declare const validation: {
     hasRules: (rules?: Rule[] | string, ruleName?: string | string[]) => boolean;
     getRules: (rules: Rule[] | string, ruleName: string) => string | undefined;
 };
-export declare const useValidation: (value?: any, rules?: Rule[] | string, includes?: string, sleep?: boolean) => [string, (message: string) => void];
 export {};

package/dist/validation/validation.js

@@ -1,5 +1,3 @@
-"use client";
-import { useEffect, useState } from "react";
 import validator from "validator";
 import { validationLangs } from "./validation.langs";
 // ==========================>
@@ -128,23 +126,3 @@ export const validation = {
         return found ? found.split(":")[1] : undefined;
     }
 };
-// =========================>
-// ## Check validation Hook
-// =========================>
-export const useValidation = (value = "", rules = "", includes = "", sleep = false) => {
-    const [message, setMessage] = useState("");
-    useEffect(() => {
-        if (rules && !sleep) {
-            const { valid, message } = validation.check({ value, rules });
-            setMessage(valid ? "" : message);
-        }
-        else {
-            setMessage("");
-        }
-    }, [value, rules, sleep]);
-    useEffect(() => {
-        if (includes)
-            setMessage(includes);
-    }, [includes]);
-    return [message, setMessage];
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skalfa/skalfa-app-core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Core framework engine and foundational utility hook library for the Skalfa Next.js frontend.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -20,6 +20,7 @@
   "dependencies": {
     "axios": "^1.12.0",
     "clsx": "^2.1.1",
+    "commander": "^12.1.0",
     "crypto-js": "^4.2.0",
     "js-cookie": "^3.0.5",
     "lz-string": "^1.5.0",