dff-util 1.0.0

package/README.md

@@ -0,0 +1,46 @@
+## Session Info
+
+```
+export type SessionInfo = {
+  id: string;
+  email?: string;
+  mobile?: string;
+  name?: string;
+  role: string;
+  requestId?: string;
+  token?: string;
+  exp?: number;
+};
+```
+
+## ErrorResponse
+
+```
+new ErrorResponse(message): {
+    status: 0,
+    message: 'ERROR',
+    data: message
+}
+```
+
+### util
+
+```
+UniqueCode();
+UniqueByType(name, type) =>  key give Upper case without special char by type
+Key(name) =>  key give Upper case without special char
+DaysBack(date, addDays, isDays)
+AddDays(date, addDays, isDays)
+```
+
+## Crypto encrypt
+
+```
+crypto.encrypt(text, key) :: string
+```
+
+## Crypto decrypt
+
+```
+crypto.decrypt(text, key) :: string
+```

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from './main/util';
+export * from './main/crypto-decrypt';
+export * from './main/crypto-encrypt';
+export * from './main/jwt-util';
+export * from './main/http';
+export * from './main/regexr';
+export * from './main/const-value';
+export * from './main/const-type';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./main/util"), exports);
+__exportStar(require("./main/crypto-decrypt"), exports);
+__exportStar(require("./main/crypto-encrypt"), exports);
+__exportStar(require("./main/jwt-util"), exports);
+__exportStar(require("./main/http"), exports);
+__exportStar(require("./main/regexr"), exports);
+__exportStar(require("./main/const-value"), exports);
+__exportStar(require("./main/const-type"), exports);

package/dist/main/const-type.d.ts

@@ -0,0 +1,28 @@
+export type SessionInfo = {
+    id: string;
+    email?: string;
+    mobile?: string;
+    name?: string;
+    role: string;
+    requestId?: string;
+    token?: string;
+    exp?: number;
+};
+export type SessionUser = {
+    id: string;
+    email?: string;
+    mobile?: string;
+    name?: string;
+    role: string;
+};
+export declare const ErrorResponse: (message: string, error?: any) => {
+    status: number;
+    type: string;
+    message: string;
+    error: any;
+};
+export declare const SuccessResponse: (data: any) => {
+    status: number;
+    type: string;
+    data: any;
+};

package/dist/main/const-type.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuccessResponse = exports.ErrorResponse = void 0;
+const ErrorResponse = (message, error) => {
+    return {
+        status: 0,
+        type: 'ERROR',
+        message: message,
+        error: error,
+    };
+};
+exports.ErrorResponse = ErrorResponse;
+const SuccessResponse = (data) => {
+    return {
+        status: 1,
+        type: 'SUCCESS',
+        data: data,
+    };
+};
+exports.SuccessResponse = SuccessResponse;

package/dist/main/const-value.d.ts

@@ -0,0 +1,36 @@
+export declare const ConstValue: {
+    AND: string;
+    OR: string;
+    NOT: string;
+    AT: string;
+    HASH: string;
+    DOLLAR: string;
+    PERCENT: string;
+    CARET: string;
+    AMPERSAND: string;
+    ASTERISK: string;
+    TILDE: string;
+    COLON: string;
+    SEMICOLON: string;
+    DOUBLE_QUOTE: string;
+    SINGLE_QUOTE: string;
+    COMMA: string;
+    PERIOD: string;
+    SLASH: string;
+    QUESTION_MARK: string;
+    PLUS: string;
+    UNDERSCORE: string;
+    HYPHEN: string;
+    EQUALS: string;
+    BACKSLASH: string;
+    PIPE: string;
+    SPACE: string;
+    EMPTY: string;
+    TRUE: string;
+    FALSE: string;
+    NULL: string;
+    UNDEFINED: string;
+    STR_AND: string;
+    STR_OR: string;
+    STR_NOT: string;
+};

package/dist/main/const-value.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstValue = void 0;
+exports.ConstValue = {
+    // Logical operators
+    AND: '&&',
+    OR: '||',
+    NOT: '!',
+    // Common special characters
+    AT: '@',
+    HASH: '#',
+    DOLLAR: '$',
+    PERCENT: '%',
+    CARET: '^',
+    AMPERSAND: '&',
+    ASTERISK: '*',
+    TILDE: '~',
+    COLON: ':',
+    SEMICOLON: ';',
+    DOUBLE_QUOTE: '"',
+    SINGLE_QUOTE: "'",
+    COMMA: ',',
+    PERIOD: '.',
+    SLASH: '/',
+    QUESTION_MARK: '?',
+    PLUS: '+',
+    UNDERSCORE: '_',
+    HYPHEN: '-',
+    EQUALS: '=',
+    BACKSLASH: '\\',
+    PIPE: '|',
+    // Space
+    SPACE: ' ',
+    EMPTY: '',
+    // Other
+    TRUE: 'true',
+    FALSE: 'false',
+    NULL: 'null',
+    UNDEFINED: 'undefined',
+    STR_AND: 'AND',
+    STR_OR: 'OR',
+    STR_NOT: 'NOT',
+};

package/dist/main/crypto-decrypt.d.ts

@@ -0,0 +1 @@
+export declare const Decrypt: (text: string, key: string) => Promise<string>;

package/dist/main/crypto-decrypt.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Decrypt = void 0;
+const hexStringToArrayBuffer = (hex) => {
+    const hexMatches = hex.match(/.{1,2}/g) || [];
+    const typedArray = new Uint8Array(hexMatches.map((byte) => parseInt(byte, 16)));
+    return typedArray.buffer;
+};
+const Decrypt = (text, key) => __awaiter(void 0, void 0, void 0, function* () {
+    const [ivHex, dataHex] = text.split(':');
+    const iv = hexStringToArrayBuffer(ivHex);
+    const data = hexStringToArrayBuffer(dataHex);
+    const alg = { name: 'AES-CBC', iv: iv };
+    const cryptoKey = yield crypto.subtle.importKey('raw', hexStringToArrayBuffer(key), alg, false, ['decrypt']);
+    const decrypted = yield crypto.subtle.decrypt(alg, cryptoKey, data);
+    const dec = new TextDecoder();
+    return dec.decode(decrypted);
+});
+exports.Decrypt = Decrypt;

package/dist/main/crypto-encrypt.d.ts

@@ -0,0 +1 @@
+export declare const Encrypt: (text: string, key: string) => string;

package/dist/main/crypto-encrypt.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encrypt = void 0;
+const crypto = __importStar(require("crypto"));
+const Encrypt = (text, key) => {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key, 'hex'), iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+};
+exports.Encrypt = Encrypt;

package/dist/main/http.d.ts

@@ -0,0 +1,24 @@
+export declare enum RespType {
+    JSON = "json",
+    TEXT = "text",
+    BLOB = "blob",
+    FORM_DATA = "formData",
+    ARRAY_BUFFER = "arrayBuffer"
+}
+export declare const HttpHeaders: {
+    'Content-Type': string;
+    authorization: null;
+    'x-request-id': null;
+};
+export declare class Http {
+    static API_BASE_URL: string | undefined;
+    static TOKEN_URL: string;
+    private static RespData;
+    static Get(url: string, params: any, headers: any, type?: RespType): Promise<any>;
+    static Post(url: string, data: any, headers: any, type?: RespType): Promise<any>;
+    static Put(url: string, data: any, headers: any, type?: RespType): Promise<any>;
+    static Delete(url: string, params: any, headers: any, type?: RespType): Promise<any>;
+    static Token(sessionInfo: any, key: string, type?: RespType): Promise<any>;
+    static Upload(fullUrl: string, file: File, data?: Record<string, any>, headers?: any, type?: RespType): Promise<any>;
+    static Download(fullUrl: string, params: any, headers?: any): Promise<Buffer>;
+}

package/dist/main/http.js

@@ -0,0 +1,167 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Http = exports.HttpHeaders = exports.RespType = void 0;
+var RespType;
+(function (RespType) {
+    RespType["JSON"] = "json";
+    RespType["TEXT"] = "text";
+    RespType["BLOB"] = "blob";
+    RespType["FORM_DATA"] = "formData";
+    RespType["ARRAY_BUFFER"] = "arrayBuffer";
+})(RespType || (exports.RespType = RespType = {}));
+exports.HttpHeaders = {
+    'Content-Type': 'application/json',
+    authorization: null,
+    'x-request-id': null,
+};
+class Http {
+    static RespData(response_1) {
+        return __awaiter(this, arguments, void 0, function* (response, type = RespType.JSON) {
+            if (!response.ok) {
+                throw { status: response.status || 0, statusText: response.statusText || response };
+            }
+            switch (type) {
+                case RespType.JSON:
+                    return yield (response === null || response === void 0 ? void 0 : response.json());
+                case RespType.TEXT:
+                    return yield (response === null || response === void 0 ? void 0 : response.text());
+                case RespType.BLOB:
+                    return yield (response === null || response === void 0 ? void 0 : response.blob());
+                case RespType.FORM_DATA:
+                    return yield (response === null || response === void 0 ? void 0 : response.formData());
+                case RespType.ARRAY_BUFFER:
+                    return yield (response === null || response === void 0 ? void 0 : response.arrayBuffer());
+                case RespType.BLOB:
+                    return yield (response === null || response === void 0 ? void 0 : response.blob());
+                default:
+                    return null;
+            }
+        });
+    }
+    static Get(url_1, params_1, headers_1) {
+        return __awaiter(this, arguments, void 0, function* (url, params, headers, type = RespType.JSON) {
+            url = Http.API_BASE_URL + url;
+            const fullUrl = params ? `${url}?${new URLSearchParams(params).toString()}` : url;
+            try {
+                const requestOptions = { method: 'GET', headers: headers || exports.HttpHeaders };
+                const response = yield fetch(fullUrl, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpGet error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static Post(url_1, data_1, headers_1) {
+        return __awaiter(this, arguments, void 0, function* (url, data, headers, type = RespType.JSON) {
+            url = Http.API_BASE_URL + url;
+            try {
+                const requestOptions = { method: 'POST', body: JSON.stringify(data || {}), headers: headers || exports.HttpHeaders };
+                const response = yield fetch(url, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpPost error: ', error);
+                throw { url: url, requestId: exports.HttpHeaders['x-request-id'], body: data, error: error };
+            }
+        });
+    }
+    static Put(url_1, data_1, headers_1) {
+        return __awaiter(this, arguments, void 0, function* (url, data, headers, type = RespType.JSON) {
+            url = Http.API_BASE_URL + url;
+            try {
+                const requestOptions = { method: 'PUT', body: JSON.stringify(data || {}), headers: headers || exports.HttpHeaders };
+                const response = yield fetch(url, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpPut error: ', error);
+                throw { url: url, requestId: exports.HttpHeaders['x-request-id'], body: data, error: error };
+            }
+        });
+    }
+    static Delete(url_1, params_1, headers_1) {
+        return __awaiter(this, arguments, void 0, function* (url, params, headers, type = RespType.JSON) {
+            url = Http.API_BASE_URL + url;
+            const fullUrl = params ? `${url}?${new URLSearchParams(params).toString()}` : url;
+            try {
+                const requestOptions = { method: 'DELETE', headers: headers || exports.HttpHeaders };
+                const response = yield fetch(fullUrl, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpDelete error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static Token(sessionInfo_1, key_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionInfo, key, type = RespType.TEXT) {
+            const url = `${Http.API_BASE_URL}${Http.TOKEN_URL}`;
+            const params = { key: key, payload: JSON.stringify(sessionInfo) };
+            const fullUrl = `${url}?${new URLSearchParams(params).toString()}`;
+            try {
+                const requestOptions = { method: 'GET', headers: exports.HttpHeaders };
+                const response = yield fetch(fullUrl, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpToken error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static Upload(fullUrl_1, file_1) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, file, data = {}, headers = exports.HttpHeaders, type = RespType.JSON) {
+            const formData = new FormData();
+            formData.append('file', file);
+            for (const key in data) {
+                if (data[key] !== undefined && data[key] !== null) {
+                    formData.append(key, data[key]);
+                }
+            }
+            try {
+                const requestOptions = {
+                    method: 'POST',
+                    body: formData,
+                    headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'multipart/form-data' }),
+                };
+                const response = yield fetch(fullUrl, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpUpload error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static Download(fullUrl_1, params_1) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, params, headers = exports.HttpHeaders) {
+            fullUrl = params ? `${fullUrl}?${new URLSearchParams(params).toString()}` : fullUrl;
+            try {
+                const requestOptions = { method: 'GET', headers: headers || exports.HttpHeaders };
+                const response = yield fetch(fullUrl, requestOptions);
+                const blob = yield response.blob();
+                const buffer = Buffer.from(yield blob.arrayBuffer());
+                return buffer;
+            }
+            catch (error) {
+                console.error('HttpDownload error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+}
+exports.Http = Http;
+Http.API_BASE_URL = process.env.API_BASE_URL;
+Http.TOKEN_URL = `/apisix/plugin/jwt/sign`;

package/dist/main/jwt-util.d.ts

@@ -0,0 +1,4 @@
+import * as jwt from 'jsonwebtoken';
+export declare const JwtEncode: (data: any, token: string, expiresIn?: number) => string;
+export declare const JwtVerify: (data: any, token: string) => string | jwt.JwtPayload;
+export declare const JwtDecode: (token: any) => string | jwt.JwtPayload | null;

package/dist/main/jwt-util.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtDecode = exports.JwtVerify = exports.JwtEncode = void 0;
+const jwt = __importStar(require("jsonwebtoken"));
+const JwtEncode = (data, token, expiresIn = 86400) => {
+    return jwt.sign(data, token, {
+        expiresIn: expiresIn,
+    });
+};
+exports.JwtEncode = JwtEncode;
+const JwtVerify = (data, token) => {
+    if (data) {
+        try {
+            data = data.replace('jwt ', '').replace('JWT ', '');
+            data = data.replace('Bearer ', '').replace('bearer ', '').replace('BEARER', '');
+            return jwt.verify(data, token);
+        }
+        catch (err) {
+            throw { name: 'error', message: 'Token is not valid' };
+        }
+    }
+    else {
+        throw { name: 'error', message: 'Auth token is not supplied' };
+    }
+};
+exports.JwtVerify = JwtVerify;
+const JwtDecode = (token) => {
+    if (token) {
+        try {
+            token = token.replace('jwt ', '').replace('JWT ', '');
+            token = token.replace('Bearer ', '').replace('bearer ', '').replace('BEARER', '');
+            return jwt.decode(token);
+        }
+        catch (err) {
+            console.log(err);
+            throw { name: 'error', message: 'Token is not valid' };
+        }
+    }
+    else {
+        throw { name: 'error', message: 'Auth token is not supplied' };
+    }
+};
+exports.JwtDecode = JwtDecode;

package/dist/main/regexr.d.ts

@@ -0,0 +1,22 @@
+export declare const RegExp: {
+    NON_ALPHA_NUMERIC: RegExp;
+    DIGITS_ONLY: RegExp;
+    ALPHABETS_ONLY: RegExp;
+    ALPHA_NUMERIC: RegExp;
+    EMAIL: RegExp;
+    URL: RegExp;
+    PHONE_US: RegExp;
+    STRONG_PASSWORD: RegExp;
+    WHITESPACE: RegExp;
+    HTML_TAG: RegExp;
+    IPV4: RegExp;
+    DATE_YYYY_MM_DD: RegExp;
+    TIME_HH_MM: RegExp;
+    ISO_DATETIME: RegExp;
+    HEX_COLOR: RegExp;
+    UUID_V4: RegExp;
+    NON_ASCII: RegExp;
+    LINE_BREAK: RegExp;
+    AMOUNT_DECIMAL: RegExp;
+    PERCENTAGE: RegExp;
+};

package/dist/main/regexr.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExp = void 0;
+exports.RegExp = {
+    // Matches any non-alphanumeric characters
+    NON_ALPHA_NUMERIC: /[^\w\s]/g,
+    // Matches only numeric digits (0-9)
+    DIGITS_ONLY: /^\d+$/,
+    // Matches only alphabets (case-insensitive)
+    ALPHABETS_ONLY: /^[a-zA-Z]+$/,
+    // Matches alphanumeric characters (letters and digits)
+    ALPHA_NUMERIC: /^[a-zA-Z0-9]+$/,
+    // Matches an email address
+    EMAIL: /^[\w.%+-]+@[a-zA-Z\d.-]+\.[a-zA-Z]{2,}$/,
+    // Matches a URL
+    URL: /^(https?:\/\/)?([\w.-]+)\.([a-z]{2,6}\.?)(\/[\w.-]*)*\/?$/i,
+    // Matches a US phone number (formats like (123) 456-7890, 123-456-7890, etc.)
+    PHONE_US: /^(\(\d{3}\)\s?|\d{3}[-.\s]?)?\d{3}[-.\s]?\d{4}$/,
+    // Matches a password with at least one lowercase, one uppercase, one digit, and one special character
+    STRONG_PASSWORD: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[\W_]).{8,}$/,
+    // Matches whitespace characters
+    WHITESPACE: /\s+/g,
+    // Matches any HTML tags
+    HTML_TAG: /<\/?[\w\s="/.':;#-\/\?]+>/gi,
+    // Matches IPv4 addresses
+    IPV4: /^(25[0-5]|2[0-4]\d|1?\d?\d)(\.(25[0-5]|2[0-4]\d|1?\d?\d)){3}$/,
+    // Matches dates in YYYY-MM-DD format
+    DATE_YYYY_MM_DD: /^\d{4}-\d{2}-\d{2}$/,
+    // Matches time in HH:MM 24-hour format
+    TIME_HH_MM: /^([01]\d|2[0-3]):([0-5]\d)$/,
+    // Matches ISO 8601 datetime format (e.g., 2023-08-15T13:45:30Z, 2023-08-15T13:45:30+05:30)
+    ISO_DATETIME: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/,
+    // Matches a hexadecimal color code
+    HEX_COLOR: /^#?([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/,
+    // Matches a UUID (version 4)
+    UUID_V4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    // Matches non-ASCII characters
+    NON_ASCII: /[^\x00-\x7F]/g,
+    // Matches line breaks (newlines)
+    LINE_BREAK: /\r?\n/g,
+    // Matches amounts in decimal format (e.g., 123.45, 0.99, 1000)
+    AMOUNT_DECIMAL: /^\d+(\.\d{1,2})?$/,
+    // Matches percentages from 0-100 or in decimal format (e.g., 25%, 99.99%, 100, 0.5)
+    PERCENTAGE: /^(100(\.0{1,2})?|0|0?\.\d{1,2}|[1-9]?\d(\.\d{1,2})?)%?$/,
+};

package/dist/main/util.d.ts

@@ -0,0 +1,7 @@
+export declare const AppRandomString: (length: number, charset: string) => string;
+export declare const AppUniqueCode: () => string;
+export declare const AppUniqueCodeByType: (name: string, type?: null) => string;
+export declare const AppKey: (name: string) => string | null;
+export declare const AppDaysBack: (date: Date, backValue: number, isDays?: boolean) => Date;
+export declare const AppAddDays: (date: Date, addDays: number, isDays?: boolean) => Date;
+export declare const AppUUID4: () => string;

package/dist/main/util.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppUUID4 = exports.AppAddDays = exports.AppDaysBack = exports.AppKey = exports.AppUniqueCodeByType = exports.AppUniqueCode = exports.AppRandomString = void 0;
+const randomstring_1 = require("randomstring");
+const regexr_1 = require("./regexr");
+const AppRandomString = (length, charset) => {
+    return (0, randomstring_1.generate)({ length: length, charset: charset });
+};
+exports.AppRandomString = AppRandomString;
+let uniqueId = 0;
+const AppUniqueCode = () => {
+    let time = new Date().getTime();
+    if (uniqueId == time) {
+        while (new Date().getTime() < 1 + time) { }
+        time = new Date().getTime();
+    }
+    uniqueId = time;
+    return time.toString(36).toUpperCase();
+};
+exports.AppUniqueCode = AppUniqueCode;
+const AppUniqueCodeByType = (name, type = null) => {
+    let str = '';
+    if (type) {
+        str = type + '_' + name;
+    }
+    else {
+        str = name + '_' + (0, exports.AppUniqueCode)();
+    }
+    str = str.replace(regexr_1.RegExp.NON_ALPHA_NUMERIC, '_');
+    str = str.replace(/\s/g, '_');
+    str = str.substr(0, 128);
+    return str.toUpperCase();
+};
+exports.AppUniqueCodeByType = AppUniqueCodeByType;
+const AppKey = (name) => {
+    if (name == null)
+        return null;
+    let str = '';
+    str = name.trim();
+    str = str.replace(regexr_1.RegExp.NON_ALPHA_NUMERIC, '_');
+    str = str.replace(/\s/g, '_');
+    return str.toUpperCase();
+};
+exports.AppKey = AppKey;
+const AppDaysBack = (date, backValue, isDays = true) => {
+    date = new Date(date);
+    if (isDays) {
+        date.setDate(date.getDate() - backValue);
+    }
+    else {
+        date.setMilliseconds(date.getMilliseconds() - backValue);
+    }
+    date = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    return date;
+};
+exports.AppDaysBack = AppDaysBack;
+const AppAddDays = (date, addDays, isDays = true) => {
+    date = new Date(date);
+    if (isDays) {
+        date.setDate(date.getDate() + addDays);
+    }
+    else {
+        date.setMilliseconds(date.getMilliseconds() + addDays);
+    }
+    date = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    return date;
+};
+exports.AppAddDays = AppAddDays;
+const AppUUID4 = () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+        const r = (Math.random() * 16) | 0;
+        const v = c == 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+exports.AppUUID4 = AppUUID4;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "dff-util",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "npm",
+    "dff",
+    "util"
+  ],
+  "author": "DesignForFeature",
+  "license": "ISC",
+  "description": "DesignForFeature Utilies",
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.6",
+    "@types/node": "^20.14.10",
+    "@types/randomstring": "^1.3.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2",
+    "randomstring": "1.3.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,110 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "commonjs", /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    // "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist", /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "isolatedDeclarations": true,                     /* Require sufficient annotation on exports so other tools can trivially generate declaration files. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true, /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "include": [ "src/**/*" ],
+  "exclude": [ "node_modules", "**/*.spec.ts" ]
+}