dff-util 1.1.0 → 1.1.2

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './main/util';
+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,22 @@
+"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/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,24 @@
+export type SessionInfo = {
+    id: string;
+    email?: string;
+    mobile?: string;
+    name?: string;
+    roles: string[];
+    requestId?: string;
+    token?: string;
+    iat?: number;
+    exp?: number;
+    key: string;
+};
+export type SessionUser = {
+    id: string;
+    email?: string;
+    mobile?: string;
+    name?: string;
+    roles: string[];
+};
+export type ResponseType = {
+    status?: string | number;
+    data?: any;
+    error?: any;
+};

package/dist/main/const-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,29 @@
+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 const BaseHeaders: {
+    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, appKey: string, apiKey?: string, type?: RespType): Promise<any>;
+    static FormUpload(url: string, file: File, isHeadersAddMultiForm?: boolean, data?: Record<string, any>, headers?: any, method?: 'POST' | 'PUT', type?: RespType): Promise<any>;
+    static CloudUpload(fullUrl: string, file: File, headers?: any, method?: 'POST' | 'PUT'): Promise<Response>;
+    static FileDownload(fullUrl: string, params: any, headers?: any, method?: string): Promise<Buffer<ArrayBufferLike>>;
+}

package/dist/main/http.js

@@ -0,0 +1,197 @@
+"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.BaseHeaders = 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,
+};
+exports.BaseHeaders = {
+    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 = url.startsWith('http') ? 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 = url.startsWith('http') ? 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 = url.startsWith('http') ? 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 = url.startsWith('http') ? 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, appKey_1, apiKey_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionInfo, appKey, apiKey, type = RespType.TEXT) {
+            const url = `${Http.API_BASE_URL}${Http.TOKEN_URL}`;
+            const params = { key: appKey, payload: JSON.stringify(sessionInfo) };
+            const fullUrl = `${url}?${new URLSearchParams(params).toString()}`;
+            const headers = Object.assign(Object.assign({}, Headers), { 'X-API-KEY': apiKey || '' });
+            try {
+                const requestOptions = { method: 'GET', headers: headers };
+                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 FormUpload(url_1, file_1) {
+        return __awaiter(this, arguments, void 0, function* (url, file, isHeadersAddMultiForm = false, data = {}, headers = exports.BaseHeaders, method = 'PUT', type = RespType.JSON) {
+            url = url.startsWith('http') ? url : Http.API_BASE_URL + url;
+            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]);
+                }
+            }
+            if (isHeadersAddMultiForm) {
+                headers = Object.assign(Object.assign({}, headers), { 'Content-Type': headers['Content-Type'] || 'multipart/form-data' });
+            }
+            try {
+                const requestOptions = {
+                    method: method,
+                    body: formData,
+                    headers: Object.assign({}, headers),
+                };
+                console.log(requestOptions);
+                const response = yield fetch(url, requestOptions);
+                return yield Http.RespData(response, type);
+            }
+            catch (error) {
+                console.error('HttpUpload error: ', error);
+                throw { url: url, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static CloudUpload(fullUrl_1, file_1) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, file, headers = null, method = 'PUT') {
+            headers = headers || {
+                'Content-Type': file.type,
+            };
+            try {
+                const requestOptions = {
+                    method: method,
+                    body: file,
+                    headers: Object.assign({}, headers),
+                };
+                const response = yield fetch(fullUrl, requestOptions);
+                return response;
+            }
+            catch (error) {
+                console.error('HttpUpload error: ', error);
+                throw { url: fullUrl, requestId: exports.HttpHeaders['x-request-id'], error: error };
+            }
+        });
+    }
+    static FileDownload(fullUrl_1, params_1) {
+        return __awaiter(this, arguments, void 0, function* (fullUrl, params, headers = exports.HttpHeaders, method = 'GET') {
+            fullUrl = params ? `${fullUrl}?${new URLSearchParams(params).toString()}` : fullUrl;
+            try {
+                const requestOptions = { method: method, 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,27 @@
+/**
+ * Encode JWT Token with secret key, expiresIn in seconds (86400 = 1 day) default
+ * @param data
+ * @param secret
+ * @param expiresIn
+ * @returns
+ */
+export declare const JwtEncode: (data: any, secret: string, expiresIn?: number) => string;
+/**
+ * Verify JWT token with secret
+ * @param token
+ * @param secret
+ * @returns
+ */
+export declare const JwtVerify: (token: string, secret: string) => any;
+/**
+ * Decode JWT Token without verification
+ * @param token
+ * @returns
+ */
+export declare const JwtDecode: (token: string) => import("jwt-decode").JwtPayload;
+/**
+ * Check if token is expired or not
+ * @param token
+ * @returns
+ */
+export declare const JwtValid: (token: string) => boolean;

package/dist/main/jwt-util.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtValid = exports.JwtDecode = exports.JwtVerify = exports.JwtEncode = void 0;
+const jwt_encode_1 = __importDefault(require("jwt-encode"));
+const jwt_decode_1 = require("jwt-decode");
+/**
+ * Encode JWT Token with secret key, expiresIn in seconds (86400 = 1 day) default
+ * @param data
+ * @param secret
+ * @param expiresIn
+ * @returns
+ */
+const JwtEncode = (data, secret, expiresIn = 86400) => {
+    try {
+        const exp = Math.floor(Date.now() / 1000) + expiresIn;
+        const payload = Object.assign(Object.assign({}, data), { exp });
+        const token = (0, jwt_encode_1.default)(payload, secret);
+        return token;
+    }
+    catch (err) {
+        console.error('Error encoding JWT:', err);
+        throw new Error('Error encoding JWT');
+    }
+};
+exports.JwtEncode = JwtEncode;
+/**
+ * Verify JWT token with secret
+ * @param token
+ * @param secret
+ * @returns
+ */
+const JwtVerify = (token, secret) => {
+    if (token) {
+        try {
+            token = token.replace(/jwt |JWT |Bearer |bearer |BEARER /g, '');
+            const decoded = (0, jwt_decode_1.jwtDecode)(token);
+            const currentTime = Math.floor(Date.now() / 1000);
+            // Check if token is expired
+            if (decoded.exp && decoded.exp < currentTime) {
+                throw new Error('Token has expired');
+            }
+            // Since `jwt-encode` doesn't provide signature verification, manually check if the payload matches.
+            const regeneratedToken = (0, jwt_encode_1.default)(decoded, secret);
+            if (token !== regeneratedToken) {
+                throw new Error('Token is not valid');
+            }
+            return decoded;
+        }
+        catch (err) {
+            console.error('Invalid JWT:', err);
+            throw new Error('Token is not valid');
+        }
+    }
+    else {
+        throw new Error('Auth token is not supplied');
+    }
+};
+exports.JwtVerify = JwtVerify;
+/**
+ * Decode JWT Token without verification
+ * @param token
+ * @returns
+ */
+const JwtDecode = (token) => {
+    if (token) {
+        try {
+            token = token.replace(/jwt |JWT |Bearer |bearer |BEARER /g, '');
+            const decoded = (0, jwt_decode_1.jwtDecode)(token);
+            return decoded;
+        }
+        catch (err) {
+            console.error('Error decoding JWT:', err);
+            throw new Error('Token is not valid');
+        }
+    }
+    else {
+        throw new Error('Auth token is not supplied');
+    }
+};
+exports.JwtDecode = JwtDecode;
+/**
+ * Check if token is expired or not
+ * @param token
+ * @returns
+ */
+const JwtValid = (token) => {
+    try {
+        if (!token) {
+            return false;
+        }
+        const decoded = (0, jwt_decode_1.jwtDecode)(token);
+        const currentTime = Math.floor(Date.now() / 1000);
+        return !(decoded.exp && decoded.exp < currentTime);
+    }
+    catch (error) {
+        console.error('Invalid JWT:', error);
+        return false;
+    }
+};
+exports.JwtValid = JwtValid;

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 AppCodeByType: (name: string, type?: null) => string;
+export declare const AppCode: (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.AppCode = exports.AppCodeByType = 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 AppCodeByType = (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.AppCodeByType = AppCodeByType;
+const AppCode = (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.AppCode = AppCode;
+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/dist/tests/jwt.js

@@ -1,5 +1,5 @@
 "use strict";
-// bun run tests/jwt.ts
+// bun run src/tests/jwt.ts
 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) {
@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const index_1 = require("../src/index");
+const index_1 = require("../index");
 const runJwtExamples = () => __awaiter(void 0, void 0, void 0, function* () {
     const secret = 'your-secret-key';
     const payload = { userId: '123', role: 'admin' };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dff-util",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -17,13 +17,15 @@
   "license": "ISC",
   "description": "DesignForFeature Utilities",
   "devDependencies": {
+    "@types/jwt-encode": "^1.0.3",
     "@types/node": "^22.10.5",
     "@types/randomstring": "^1.3.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.7.2"
   },
   "dependencies": {
-    "jose": "^5.9.6",
+    "jwt-decode": "^4.0.0",
+    "jwt-encode": "^1.0.1",
     "randomstring": "1.3.0"
   }
 }

package/tsconfig.json

@@ -105,6 +105,6 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
-  "include": [ "src/**/*", "tests/jwt.ts" ],
+  "include": [ "src/**/*", "src/tests/jwt.ts" ],
   "exclude": [ "node_modules", "**/*.spec.ts" ]
 }

package/tests/jwt.ts

@@ -1,30 +0,0 @@
-// bun run tests/jwt.ts
-
-import { JwtEncode, JwtVerify, JwtDecode, JwtValid } from '../src/index';
-
-const runJwtExamples = async () => {
-  const secret = 'your-secret-key';
-  const payload = { userId: '123', role: 'admin' };
-
-  // 1. Encode a JWT
-  const token = await JwtEncode(payload, secret, 3600);
-  console.log('Encoded JWT Token:', token);
-
-  // 2. Verify the JWT
-  try {
-    const verifiedPayload = await JwtVerify(token, secret);
-    console.log('Verified Payload:', verifiedPayload);
-  } catch (error: any) {
-    console.error('Verification Error:', error.message);
-  }
-
-  // 3. Decode the JWT without verification
-  const decodedPayload = JwtDecode(token);
-  console.log('Decoded Payload (without verification):', decodedPayload);
-
-  // 4. Check if the JWT is valid
-  const isValid = JwtValid(token);
-  console.log('Is JWT valid:', isValid);
-};
-
-runJwtExamples();