@zuzjs/core 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -1,28 +1,36 @@
-export declare const setCookie: (key: string, value: any, expiry?: number, host?: string) => string | undefined;
-export declare const getCookie: (key: string) => string | {
-    [key: string]: string;
-} | null;
-export declare const removeCookie: (key: string) => void;
-export declare const uuid: (len?: number) => string;
-export declare const isEmail: (e: string) => boolean;
-export declare const formatBytes: (bytes: number) => string;
-export declare const formatSeconds: (n: number) => string;
-export declare const formatTime: (time: (string | number)[]) => string;
-export declare const createElem: (tag: string, classes?: string[], attrs?: {
-    [key: string]: string;
-}) => HTMLElement;
-export type ElementNode = {
-    tag: string;
-    id?: string;
-    text?: string;
-    classes?: string[];
-    attrs?: {
-        [x: string]: string;
-    };
-    childs?: ElementNode[];
+import { AxiosProgressEvent } from "axios";
+import { dynamicObject, FormatNumberParams, sortOptions } from "./types";
+export declare const __SALT: string;
+export { default as "_" } from "./withGlobals";
+export declare const numberInRange: (min: number, max: number) => number;
+export declare const toHash: (n: number, len?: number, SALT?: string | null) => string;
+export declare const fromHash: (str: string, SALT?: string | null) => number;
+export declare const MD5: (str: string) => string;
+export declare const uuid: (len: number) => string;
+export declare const ucfirst: (o: any) => string;
+export declare const urldecode: (str: string) => string;
+export declare const urlencode: (str: string) => string;
+export declare const pluralize: (word: string, count: number) => string;
+export declare const isHexColor: (color: string) => boolean;
+export declare const isRgbaColor: (color: string) => boolean;
+export declare const isHslColor: (color: string) => boolean;
+export declare const isColor: (color: string) => boolean;
+export declare const hexToRgba: (hex: string, alpha?: number) => string;
+export declare const removeDuplicates: <T>(array: T[]) => T[];
+export declare const withPost: <T>(uri: string, data: dynamicObject | FormData, timeout?: number, ignoreKind?: boolean, onProgress?: (ev: AxiosProgressEvent) => void) => Promise<T>;
+export declare const withGet: <T>(uri: string, timeout?: number, ignoreKind?: boolean) => Promise<T>;
+export declare const withTime: (fun: (...args: any[]) => any) => {
+    result: any;
+    executionTime: number;
 };
-export declare const createElems: (list: ElementNode[]) => Node[];
-export declare const getPlatform: () => "MAC" | "WIN" | "UNKNOWN";
-export declare const findParent: (node: HTMLElement, classes: string[], depth?: number) => HTMLElement | null;
-export declare const ucfirst: (str: string) => string;
-export declare const withRest: (uri: string, data: object, timeout: number | undefined, fd: object, progress?: Function, bearer?: string) => Promise<unknown>;
+export declare const time: (stamp?: number, format?: string) => string;
+export declare const timeSince: (stamp: number) => string;
+export declare const arrayRand: (arr: any[]) => any;
+export declare const formatNumber: ({ number, locale, style, decimal, currency }: FormatNumberParams) => string;
+export declare const formatSize: (bytes: number | string) => string;
+export declare const copyToClipboard: (text: string) => Promise<unknown>;
+export declare const natsort: (options?: sortOptions) => (a: string | number, b: string | number) => number;
+export declare const camelCase: (str: string, ucf?: boolean) => string;
+export declare const camelCaseToDash: (str: string) => string;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const slugify: (text: string, separator?: string) => string;

package/dist/index.js

@@ -1,112 +1,96 @@
-import Hashids from "hashids";
-import { nanoid } from "nanoid";
-import Cookies from 'js-cookie';
-import axios from 'axios';
-const _Hashids = new Hashids('', 4);
-export const setCookie = (key, value, expiry, host) => Cookies.set(key, value, { expires: expiry || 7, domain: host || window.location.host });
-export const getCookie = (key) => key == `` ? Cookies.get() : Cookies.get(key) || null;
-export const removeCookie = (key) => Cookies.remove(key);
-export const uuid = (len = 11) => nanoid(len);
-export const isEmail = (e) => {
-    let reg = /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
-    return reg.test(e);
-};
-export const formatBytes = (bytes) => {
-    var sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-    if (bytes == 0)
-        return '0 Byte';
-    var i = Math.floor(Math.log(bytes) / Math.log(1024)), nx = bytes / Math.pow(1024, i);
-    return nx.toFixed(2) + ' ' + sizes[i];
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-export const formatSeconds = (n) => {
-    let d = new Date(n * 1000).toISOString().slice(11, 19);
-    return d.indexOf("00:") > -1 ? d.replace("00:", "") : d;
-};
-export const formatTime = (time) => {
-    let _time = time.toString().match(/^([01]\d|2[0-3])(:)([0-5]\d)(:[0-5]\d)?$/) || [time];
-    let __ = [];
-    if (_time.length > 1) { // If time format correct
-        __ = _time.slice(1); // Remove full string match value
-        __[5] = +_time[0] < 12 ? 'AM' : 'PM'; // Set AM/PM
-        __[0] = +_time[0] % 12 || 12;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = exports.clamp = exports.camelCaseToDash = exports.camelCase = exports.natsort = exports.copyToClipboard = exports.formatSize = exports.formatNumber = exports.arrayRand = exports.timeSince = exports.time = exports.withTime = exports.withGet = exports.withPost = exports.removeDuplicates = exports.hexToRgba = exports.isColor = exports.isHslColor = exports.isRgbaColor = exports.isHexColor = exports.pluralize = exports.urlencode = exports.urldecode = exports.ucfirst = exports.uuid = exports.MD5 = exports.fromHash = exports.toHash = exports.numberInRange = exports["_"] = exports.__SALT = void 0;
+const axios_1 = __importDefault(require("axios"));
+const hashids_1 = __importDefault(require("hashids"));
+const js_cookie_1 = __importDefault(require("js-cookie"));
+const md5_1 = __importDefault(require("md5"));
+const moment_1 = __importDefault(require("moment"));
+const regexps_1 = require("./regexps");
+const types_1 = require("./types");
+exports.__SALT = `zuzjs-core`;
+var withGlobals_1 = require("./withGlobals");
+Object.defineProperty(exports, "_", { enumerable: true, get: function () { return __importDefault(withGlobals_1).default; } });
+const numberInRange = (min, max) => {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+exports.numberInRange = numberInRange;
+const toHash = (n, len = 6, SALT = null) => new hashids_1.default(SALT || exports.__SALT, len).encode(n);
+exports.toHash = toHash;
+const fromHash = (str, SALT = null) => {
+    try {
+        const n = new hashids_1.default(SALT || exports.__SALT, +process.env.HASHIDS_LENGTH).decode(str);
+        return n.length >= 0 ? Number(n[0]) : 0;
     }
-    return __.join('');
-};
-export const createElem = (tag, classes = [], attrs = {}) => {
-    for (var el = window.document.createElement(tag), i = 0; i < classes.length; i++)
-        "" != classes[i] && el.classList.add(classes[i]);
-    if (Object.keys(attrs).length > 0)
-        Object.keys(attrs)
-            .map((k) => el.setAttribute(k, attrs[k]));
-    return el;
-};
-export const createElems = (list) => {
-    let r = [], o;
-    list.map((item) => {
-        if (item.tag) {
-            o = createElem(item.tag, item.classes || [], item.attrs || {});
-            if (item.childs && item.childs.length > 0) {
-                let c = createElems(item.childs);
-                c.map((f) => o.appendChild(f));
-            }
-            else if (item.text && "" != item.text) {
-                // o = document.createTextNode(item.text)
-                o.textContent = item.text;
-            }
-            r.push(o);
-        }
-    });
-    return r;
-};
-export const getPlatform = () => {
-    return undefined !== typeof window ?
-        window.navigator.platform.toUpperCase().indexOf("MAC") > -1 ? `MAC` : `WIN` : `UNKNOWN`;
-};
-export const findParent = (node, classes, depth = 1) => {
-    var n, i = node.parentNode, o = 0, a = 0;
-    if (null === i || !i.classList || i.classList.length == 0)
-        return null;
-    for (n = classes.length; a < n; ++a)
-        i.classList.contains(classes[a]) && (o += 1);
-    return o === n ? i : 0 < depth ? findParent(i, classes, depth - 1) : null;
-};
-export const ucfirst = (str) => {
-    return str = str.trim(),
-        str.charAt(0).toUpperCase() + str.substring(1);
-};
-const buildFormData = (data) => {
-    var formData = new FormData();
-    var _data = Cookies.get();
-    Object.keys(_data).map(k => formData.append(k, _data[k]));
-    Object.keys(data).filter(x => x != 'files').map(k => formData.append(k, data[k]));
-    if ('files' in data)
-        [data['files']].map((f) => formData.append('files[]', f));
-    return formData;
-};
-export const withRest = async (uri, data, timeout = 60, fd, progress, bearer = `__ha`) => {
-    var Bearer = getCookie(bearer) || `${uuid(8)}^${uuid(8)}`;
-    var isWindow = typeof window !== 'undefined';
-    var cancelToken = null;
-    if (isWindow) {
-        window.__restToken = axios.CancelToken.source();
-        cancelToken = window.__restToken?.token;
+    catch (e) {
+        return 0;
+    }
+};
+exports.fromHash = fromHash;
+const MD5 = (str) => (0, md5_1.default)(str);
+exports.MD5 = MD5;
+const uuid = (len) => (0, exports.toHash)((0, exports.numberInRange)(11111111111, 999999999999));
+exports.uuid = uuid;
+const ucfirst = (o) => `${o.charAt(0).toUpperCase()}${o.substring(1, o.length)}`;
+exports.ucfirst = ucfirst;
+const urldecode = (str) => decodeURIComponent(str.replace(/\+/g, '%20'));
+exports.urldecode = urldecode;
+const urlencode = (str) => encodeURIComponent(str);
+exports.urlencode = urlencode;
+const pluralize = (word, count) => `${word}${count !== 1 ? 's' : ''}`;
+exports.pluralize = pluralize;
+const isHexColor = (color) => regexps_1.hexColorRegex.test(color);
+exports.isHexColor = isHexColor;
+const isRgbaColor = (color) => regexps_1.rgbaColorRegex.test(color);
+exports.isRgbaColor = isRgbaColor;
+const isHslColor = (color) => regexps_1.hslColorRegex.test(color);
+exports.isHslColor = isHslColor;
+// Function to validate a color string
+const isColor = (color) => (0, exports.isHexColor)(color) || (0, exports.isRgbaColor)(color) || (0, exports.isHslColor)(color);
+exports.isColor = isColor;
+const hexToRgba = (hex, alpha = 1) => {
+    // Remove the hash symbol if present
+    hex = hex.replace(/^#/, '');
+    // If shorthand hex (#RGB), expand it to full form (#RRGGBB)
+    if (hex.length === 3) {
+        hex = hex.split('').map(char => char + char).join('');
     }
-    if (fd) {
+    // Convert to integer values for RGB
+    const bigint = parseInt(hex, 16);
+    const r = (bigint >> 16) & 255;
+    const g = (bigint >> 8) & 255;
+    const b = bigint & 255;
+    return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+};
+exports.hexToRgba = hexToRgba;
+const removeDuplicates = (array) => {
+    return array.reduce((accumulator, currentValue) => {
+        if (!accumulator.includes(currentValue)) {
+            accumulator.push(currentValue);
+        }
+        return accumulator;
+    }, []);
+};
+exports.removeDuplicates = removeDuplicates;
+const withPost = async (uri, data, timeout = 60, ignoreKind = false, onProgress) => {
+    const _cookies = js_cookie_1.default.get();
+    if (data instanceof FormData) {
+        for (const c in _cookies) {
+            data.append(c, _cookies[c]);
+        }
         return new Promise((resolve, reject) => {
-            axios({
-                method: "post",
+            (0, axios_1.default)({
+                method: 'post',
                 url: uri,
-                data: buildFormData(data),
-                timeout: 1000 * timeout,
-                cancelToken: cancelToken,
+                data: data,
+                timeout: timeout * 1000,
                 headers: {
                     'Content-Type': 'multipart/form-data',
-                    'Authorization': `Bearer ${Bearer}`
                 },
-                onUploadProgress: ev => {
-                    //TODO: Add progress
-                    // if(progress) progress(ev.)
-                }
+                onUploadProgress: ev => onProgress && onProgress(ev)
             })
                 .then(resp => {
                 if (resp.data && "kind" in resp.data) {
@@ -120,26 +104,269 @@ export const withRest = async (uri, data, timeout = 60, fd, progress, bearer = `
         });
     }
     return new Promise((resolve, reject) => {
-        axios.post(uri, {
-            ...Cookies.get(),
+        axios_1.default.post(uri, {
             ...data,
-            __ustmp: new Date().getTime() / 1000
+            ..._cookies,
+            __stmp: new Date().getTime() / 1000
         }, {
             timeout: 1000 * timeout,
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${Bearer}`
-            },
-            cancelToken: cancelToken
+            }
         })
             .then(resp => {
-            if (resp.data && "kind" in resp.data) {
+            if (resp.data && (ignoreKind || ("kind" in resp.data))) {
                 resolve(resp.data);
             }
             else {
                 reject(resp.data);
             }
         })
-            .catch(err => reject(err));
+            .catch(err => {
+            if (err?.response?.data)
+                reject(err.response.data);
+            else
+                reject(err.code && err.code == `ERR_NETWORK` ? { error: err.code, message: navigator.onLine ? `Unable to connect to the server. It may be temporarily down.` : `Network error: Unable to connect. Please check your internet connection and try again.` } : err);
+        });
     });
 };
+exports.withPost = withPost;
+const withGet = async (uri, timeout = 60, ignoreKind = false) => {
+    return new Promise((resolve, reject) => {
+        axios_1.default
+            .get(uri, { timeout: timeout * 1000 })
+            .then((resp) => {
+            if (resp.data && (ignoreKind || "kind" in resp.data)) {
+                resolve(resp.data);
+            }
+            else {
+                reject(resp.data);
+            }
+        })
+            .catch((err) => {
+            if (err?.response?.data)
+                reject(err.response.data);
+            else
+                reject(err.code === `ERR_NETWORK`
+                    ? {
+                        error: err.code,
+                        message: navigator.onLine
+                            ? `Unable to connect to the server. It may be temporarily down.`
+                            : `Network error: Unable to connect. Please check your internet connection and try again.`,
+                    }
+                    : err);
+        });
+    });
+};
+exports.withGet = withGet;
+const withTime = (fun) => {
+    const start = new Date().getTime();
+    const result = fun();
+    const end = new Date().getTime();
+    return {
+        result,
+        executionTime: end - start
+    };
+};
+exports.withTime = withTime;
+const time = (stamp, format) => {
+    return stamp ?
+        moment_1.default.unix(+stamp / 1000).format(format || `YYYY-MM-DD HH:mm:ss`)
+        : (0, moment_1.default)().format(format || `YYYY-MM-DD HH:mm:ss`);
+};
+exports.time = time;
+const timeSince = (stamp) => (0, moment_1.default)(stamp).fromNow();
+exports.timeSince = timeSince;
+const arrayRand = (arr) => arr[Math.floor(Math.random() * arr.length)];
+exports.arrayRand = arrayRand;
+const formatNumber = ({ number, locale = 'en-US', style = `decimal`, decimal = 2, currency }) => {
+    if (style === 'currency' && !currency) {
+        throw new TypeError('Currency code is required with currency style.');
+    }
+    if (currency) {
+        const { code, style: currencyStyle, symbol } = currency;
+        const out = new Intl.NumberFormat(locale, {
+            style: `currency`,
+            currency: code,
+            currencyDisplay: currencyStyle,
+            minimumFractionDigits: +number % 1 > 0 ? decimal : 0,
+            maximumFractionDigits: +number % 1 > 0 ? decimal : 0
+        }).format(+number);
+        return symbol ? out.replace(new RegExp(`\\${code}`, 'g'), symbol) : out;
+    }
+    return new Intl.NumberFormat(locale, {
+        style,
+        minimumFractionDigits: +number % 1 > 0 ? 2 : 0,
+        maximumFractionDigits: +number % 1 > 0 ? 2 : 0
+    }).format(+number);
+};
+exports.formatNumber = formatNumber;
+const formatSize = (bytes) => {
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const _bytes = `string` == typeof bytes ? parseFloat(bytes) : bytes;
+    if (_bytes == 0)
+        return '0 Byte';
+    const _i = Math.floor(Math.log(_bytes) / Math.log(1024));
+    const i = `string` == typeof _i ? parseInt(_i) : _i;
+    const nx = _bytes / Math.pow(1024, i);
+    return nx.toFixed(2) + ' ' + sizes[i];
+};
+exports.formatSize = formatSize;
+const copyToClipboard = (text) => {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+        return navigator.clipboard.writeText(text);
+    }
+    else {
+        return new Promise((resolve, reject) => {
+            const textarea = document.createElement("textarea");
+            textarea.value = text;
+            textarea.style.position = "fixed"; // Prevent scrolling to bottom of page in MS Edge.
+            document.body.appendChild(textarea);
+            textarea.focus();
+            textarea.select();
+            try {
+                document.execCommand("copy");
+                resolve(`Copied to clipboard`);
+            }
+            catch (err) {
+                // console.error("Fallback: Oops, unable to copy", err);
+                reject(err);
+            }
+            document.body.removeChild(textarea);
+        });
+    }
+};
+exports.copyToClipboard = copyToClipboard;
+const natsort = (options = {
+    direction: types_1.SORT.Asc,
+    caseSensitive: false,
+}) => {
+    const ore = /^0/;
+    const sre = /\s+/g;
+    const tre = /^\s+|\s+$/g;
+    // unicode
+    const ure = /[^\x00-\x80]/;
+    // hex
+    const hre = /^0x[0-9a-f]+$/i;
+    // numeric
+    const nre = /(0x[\da-fA-F]+|(^[\+\-]?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?(?=\D|\s|$))|\d+)/g;
+    // datetime
+    const dre = /(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[\/\-]\d{1,4}[\/\-]\d{1,4}|^\w+, \w+ \d+, \d{4})/; // tslint:disable-line
+    const GREATER = options.direction == types_1.SORT.Desc ? -1 : 1;
+    const SMALLER = -GREATER;
+    const _normalize = !options.caseSensitive
+        ? (s) => s.toString().toLowerCase().replace(tre, '')
+        : (s) => (`${s}`).replace(tre, '');
+    const _tokenize = (s) => {
+        return s.replace(nre, '\0$1\0')
+            .replace(/\0$/, '')
+            .replace(/^\0/, '')
+            .split('\0');
+    };
+    const _parse = (s, l) => {
+        return (!s.match(ore) || l === 1) &&
+            parseFloat(s)
+            || s.replace(sre, ' ').replace(tre, '')
+            || 0;
+    };
+    return function (a, b) {
+        const aa = _normalize(a);
+        const bb = _normalize(b);
+        if (!aa && !bb) {
+            return 0;
+        }
+        if (!aa && bb) {
+            return SMALLER;
+        }
+        if (aa && !bb) {
+            return GREATER;
+        }
+        const aArr = _tokenize(aa);
+        const bArr = _tokenize(bb);
+        // hex or date detection
+        const aHex = aa.match(hre);
+        const bHex = bb.match(hre);
+        const av = (aHex && bHex) ? parseInt(aHex[0], 16) : (aArr.length !== 1 && Date.parse(aa));
+        const bv = (aHex && bHex)
+            ? parseInt(bHex[0], 16)
+            : av && bb.match(dre) && Date.parse(bb) || null;
+        // try and sort Hex codes or Dates
+        if (bv) {
+            if (av === bv) {
+                return 0;
+            }
+            if (typeof av === 'number' && typeof bv === 'number' && av < bv) {
+                return SMALLER;
+            }
+            if (typeof av === 'number' && av > bv) {
+                return GREATER;
+            }
+        }
+        const al = aArr.length;
+        const bl = bArr.length;
+        // handle numeric strings and default strings
+        for (let i = 0, l = Math.max(al, bl); i < l; i += 1) {
+            const af = _parse(aArr[i] || '', al);
+            const bf = _parse(bArr[i] || '', bl);
+            if (isNaN(af) !== isNaN(bf)) {
+                return isNaN(af) ? GREATER : SMALLER;
+            }
+            if (ure.test(af + bf) && af.localeCompare) {
+                const comp = af.localeCompare(bf);
+                if (comp > 0) {
+                    return GREATER;
+                }
+                if (comp < 0) {
+                    return SMALLER;
+                }
+                if (i === l - 1) {
+                    return 0;
+                }
+            }
+            if (af < bf) {
+                return SMALLER;
+            }
+            if (af > bf) {
+                return GREATER;
+            }
+            if (`${af}` < `${bf}`) {
+                return SMALLER;
+            }
+            if (`${af}` > `${bf}`) {
+                return GREATER;
+            }
+        }
+        return 0;
+    };
+};
+exports.natsort = natsort;
+const camelCase = (str, ucf = false) => {
+    return str
+        .toLowerCase()
+        .split(/[^a-zA-Z0-9]+/) // Split by any non-alphanumeric character
+        .map((word, index) => index === 0
+        ? ucf ? (0, exports.ucfirst)(word) : word
+        : (0, exports.ucfirst)(word))
+        .join('');
+};
+exports.camelCase = camelCase;
+const camelCaseToDash = (str) => str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+exports.camelCaseToDash = camelCaseToDash;
+const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+exports.clamp = clamp;
+const slugify = (text, separator = "-") => {
+    if (undefined == text) {
+        console.log(text, `is undefined`);
+        return ``;
+    }
+    return text
+        .normalize("NFKD") // Normalize accents (e.g., é → e)
+        .replace(/[\u0300-\u036f]/g, "") // Remove diacritic marks
+        .toLowerCase()
+        .replace(/[^a-z0-9\p{L}\p{N}]+/gu, separator) // Keep letters/numbers from all languages
+        .replace(new RegExp(`\\${separator}{2,}`, "g"), separator) // Remove duplicate separators
+        .replace(new RegExp(`^\\${separator}|\\${separator}$`, "g"), ""); // Trim separators from ends
+};
+exports.slugify = slugify;

package/dist/regexps.d.ts

@@ -0,0 +1,3 @@
+export declare const hexColorRegex: RegExp;
+export declare const rgbaColorRegex: RegExp;
+export declare const hslColorRegex: RegExp;

package/dist/regexps.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hslColorRegex = exports.rgbaColorRegex = exports.hexColorRegex = void 0;
+// Hex color regex (#RGB, #RRGGBB)
+exports.hexColorRegex = /^#([A-Fa-f0-9]{3}){1,2}$/;
+// RGBA color regex (rgba(255, 255, 255, 1))
+exports.rgbaColorRegex = /^rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(,\s*((0|1|0?\.\d+)\s*))?\)$/;
+// HSL color regex (hsl(360, 100%, 100%))
+exports.hslColorRegex = /^hsl\(\s*(\d{1,3})\s*,\s*(\d{1,3})%\s*,\s*(\d{1,3})%\s*\)$/;

package/dist/types.d.ts

@@ -1,6 +1,22 @@
-declare global {
-    interface Window {
-        __restToken: any;
-    }
+export type dynamicObject = {
+    [x: string]: any;
+};
+export interface FormatNumberParams {
+    number: number | string;
+    locale: string;
+    style?: `decimal` | `currency` | `percent`;
+    decimal?: number;
+    currency?: {
+        code: string;
+        style: `symbol` | `code` | `name`;
+        symbol?: string;
+    };
 }
-export {};
+export declare enum SORT {
+    Asc = "ASC",
+    Desc = "DESC"
+}
+export type sortOptions = {
+    direction?: SORT;
+    caseSensitive?: boolean;
+};

package/dist/types.js

@@ -1 +1,8 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SORT = void 0;
+var SORT;
+(function (SORT) {
+    SORT["Asc"] = "ASC";
+    SORT["Desc"] = "DESC";
+})(SORT || (exports.SORT = SORT = {}));

package/dist/withGlobals.d.ts

@@ -0,0 +1,25 @@
+declare class withGlobals {
+    _: any;
+    constructor(value: any);
+    isTypeof(v: any): boolean;
+    isFunction(): boolean;
+    isArray(): boolean;
+    isNull(): boolean;
+    isString(): boolean;
+    isNumber(): boolean;
+    isObject(): boolean;
+    isEmpty(): boolean;
+    isEmail(): boolean;
+    isUrl(): boolean;
+    toLowerCase(): this;
+    equals(v: any): boolean;
+    ucfirst(): this;
+    formatString(v: string | number, ...vv: (string | number)[]): this;
+    camelCase(): this;
+    value(): any;
+    valueOf(): any;
+    toString(): string;
+    [Symbol.toPrimitive](hint: string): string | number | boolean;
+}
+declare const _: <T>(value: T) => withGlobals;
+export default _;

package/dist/withGlobals.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class withGlobals {
+    _;
+    constructor(value) {
+        this._ = value;
+    }
+    isTypeof(v) {
+        return typeof this._ === typeof v;
+    }
+    isFunction() {
+        return typeof this._ === "function";
+    }
+    isArray() {
+        return Array.isArray(this._);
+    }
+    isNull() {
+        return this._ === null;
+    }
+    isString() {
+        return typeof this._ === "string";
+    }
+    isNumber() {
+        return /^[+-]?\d+(\.\d+)?$/.test(this._);
+    }
+    isObject() {
+        return typeof this._ === "object" && !Array.isArray(this._) && this._ !== null;
+    }
+    isEmpty() {
+        if (Array.isArray(this._))
+            return this._.length === 0;
+        if (typeof this._ === "object" && this._ !== null)
+            return Object.keys(this._).length === 0;
+        return this._ === "" || String(this._).length === 0;
+    }
+    isEmail() {
+        return typeof this._ === "string" && /^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(this._);
+    }
+    isUrl() {
+        return typeof this._ === "string" && /^(https?:\/\/)?(www\.)?([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(\/[^\s]*)?$/.test(this._);
+    }
+    toLowerCase() {
+        this._ = typeof this._ === "string" ? this._.toLowerCase() : String(this._).toLowerCase();
+        return this;
+    }
+    equals(v) { return this._ === v; }
+    ucfirst() {
+        this._ = typeof this._ === "string" ? this._.charAt(0).toUpperCase() + this._.slice(1) : this._;
+        return this;
+    }
+    formatString(v, ...vv) {
+        if (typeof this._ !== "string")
+            this._ = "";
+        const values = [v, ...vv];
+        this._ = this._.replace(/%(\d+)/g, (inp, index) => values[Number(index)]?.toString() || `%${index}`);
+        return this;
+    }
+    camelCase() {
+        this._ = typeof this._ === "string"
+            ? this._
+                .split(/[^a-zA-Z0-9]+/)
+                .map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1))
+                .join("")
+            : this._;
+        return this;
+    }
+    value() { return this._; }
+    valueOf() { return this._; }
+    toString() { return String(this._); }
+    [Symbol.toPrimitive](hint) {
+        if (hint === "number")
+            return Number(this._);
+        if (hint === "boolean")
+            return Boolean(this._);
+        return String(this._);
+    }
+}
+const _ = (value) => new withGlobals(value);
+exports.default = _;

package/package.json

@@ -1,16 +1,21 @@
 {
     "name": "@zuzjs/core",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "keywords": [
-        "react",
+        "core",
         "zuz",
-        "zuz.js"
+        "zuz.js",
+        "zuz orm",
+        "zuzjs"
     ],
-    "description": "ZuzJS Core",
+    "description": "ZuzJS Core Library",
     "author": "Zuz.js Team <support@zuz.com.pk>",
     "license": "MIT",
-    "type": "module",
+    "type": "commonjs",
     "main": "dist/index.js",
+    "bin": {
+        "zorm": "dist/bin.js"
+    },
     "exports": {
         ".": "./dist/index.js"
     },
@@ -23,11 +28,22 @@
     "engines": {
         "node": ">=18.17.0"
     },
+    "sideEffects": [
+        "reflect-metadata"
+    ],
     "dependencies": {
-        "axios": "1.6.5",
-        "hashids": "2.3.0",
-        "js-cookie": "3.0.5",
-        "nanoid": "5.0.4",
-        "prettier": "3.2.4"
+        "@types/hashids": "^2.0.1",
+        "@types/md5": "^2.3.5",
+        "axios": "^1.8.4",
+        "hashids": "^2.3.0",
+        "js-cookie": "^3.0.5",
+        "md5": "^2.3.0",
+        "moment": "^2.30.1",
+        "nanoid": "^5.1.0"
+    },
+    "devDependencies": {
+        "husky": "^9.1.7",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.7.3"
     }
 }