@leyyo/common 1.2.6 → 1.3.1

package/dist/index.types.d.ts

@@ -0,0 +1,510 @@
+import type { LogLevel } from "./enum";
+export type HttpStatus = number;
+export type BasicType = 'undefined' | 'string' | 'object' | 'number' | 'boolean' | 'function' | 'symbol' | 'bigint';
+export type ExtendedType = BasicType | 'array' | 'null' | 'enum' | 'class' | 'empty' | 'text' | 'nan' | 'integer' | 'date' | 'map' | 'set' | 'list';
+export type KeyValue = string | number;
+export type AnyKey = string | number | symbol;
+export type Obj = Object & {};
+export type Dict<T = unknown> = Record<KeyValue, T>;
+export type Arr<T = unknown> = Array<T>;
+export type Id = string | number;
+export type Integer = number;
+export type Float = number;
+export type Alpha = string;
+export type Text = string;
+export type Digit = string;
+export type Title = string;
+export type Description = string;
+export type RichText = string;
+export type Uuid = string;
+export type Host = string;
+export type Url = string;
+export type Email = string;
+export type Folder = string;
+export type Timestamp = number;
+export type IsoDatetime = string;
+export type IsoDate = string;
+export type IsoTime = string;
+export type Fnc<R = unknown> = ((...args: Arr) => R) & Function;
+export type Async<R = unknown> = ((...args: Arr) => Promise<R>) & AsyncGeneratorFunction;
+export interface Abstract<T = {}> extends Function {
+    prototype: T;
+    readonly name: string;
+    readonly length: number;
+    bind(thisArg: unknown, ...args: Arr): unknown;
+    apply(thisArg: unknown, args: Arr): unknown;
+    call(thisArg: unknown, ...args: Arr): unknown;
+}
+export interface ClassLike<T = {}> extends Abstract<T> {
+    new (...args: Arr): T;
+}
+export type TypeOf<C = ClassLike> = C extends ClassLike<infer T> ? T : C;
+export declare namespace Express {
+    interface Request {
+        custom?: Dict;
+    }
+    interface Response {
+        custom?: Dict;
+    }
+}
+export interface Describable {
+    description: string;
+}
+export interface Nameable {
+    name: string;
+}
+export interface HasId {
+    id?: string | number;
+}
+export type TypeOfMethod<T, M extends keyof T> = T[M] extends Function ? T[M] : never;
+export type TypeOfFnc<F extends Fnc> = F extends (...args: Arr) => infer R ? R : never;
+export type TypeOfAsync<F extends Async> = TypeOfPromise<TypeOfFnc<F>>;
+export type TypeOfPromise<P> = P extends Promise<infer R> ? R : P;
+/**
+ * String keys of an interface
+ * - Note: keyof keywords returns string|number|symbol, but it's ignore number and symbol keys
+ * */
+export type StrKey<T> = Extract<keyof T, string>;
+/**
+ * Serialized version of another type
+ */
+export type Serialized<T> = {
+    [P in keyof T]: T[P];
+};
+/**
+ * Makes mutable an interface
+ *
+ * @see Readonly
+ * */
+export type Mutable<A> = {
+    -readonly [K in keyof A]: A[K];
+};
+export type KeyOf<T> = keyof T;
+export type Keys<T> = Array<keyof T>;
+export type ValueOf<T> = T[KeyOf<T>];
+export type Values<T> = Array<T[KeyOf<T>]>;
+export type OneOrMore<T> = T | Array<T>;
+export type SetOrMore<T> = T | Set<T>;
+/**
+ * An interface which contains secure mode members and provides to shift to main mode
+ * */
+export interface ShiftSecure<S extends ShiftMain<any>> {
+    /**
+     * Shifts to secure mode
+     * */
+    get $secure(): S;
+}
+/**
+ * An interface which contains main mode members and provides to shift to secure mode
+ *
+ * IT's so useful to hide some public members
+ * - to see clean auto-completed members in IDE
+ * - to indicated that secure mode members should be used in special cases
+ * */
+export interface ShiftMain<M extends ShiftSecure<any>> {
+    /**
+     * Shifts to main mode
+     * */
+    get $back(): M;
+}
+/**
+ * An interface which provides to flat generic interfaces/classes to prevent verbose casting commands
+ * */
+export interface ShiftFlat<D> {
+    /**
+     * Flats current classes, or eliminate generic parameters
+     * */
+    get $flat(): D;
+}
+/**
+ * Useful interface which provides initialization state for instances
+ * */
+export interface InitLike {
+    /**
+     * Initializes the instance
+     * */
+    $init(...args: Arr): void;
+}
+export type EnumMap<E extends KeyValue = KeyValue> = {
+    [K in E]: KeyValue;
+};
+export type EnumAlt<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumLiteral<E extends KeyValue = KeyValue> = Array<E> | ReadonlyArray<E>;
+export type EnumData<E extends KeyValue = KeyValue> = EnumMap<E> | EnumLiteral<E>;
+export type EnumType = 'map' | 'literal';
+export interface EnumItem extends EnumDefineOpt {
+    mode: LoaderMode;
+    type?: EnumType;
+    data?: EnumMap | EnumLiteral;
+    alt?: EnumAlt;
+    lazyData?: Promise<EnumMap | EnumLiteral>;
+    lazyAlt?: Promise<EnumAlt>;
+}
+export interface EnumDefineOpt {
+    name: string;
+    fqn?: string;
+    i18n?: unknown;
+}
+export interface EnumDefineEagerOpt extends EnumDefineOpt {
+    alt?: EnumAlt;
+}
+export interface EnumDefineLazyOpt extends EnumDefineOpt {
+    lazyData: Promise<EnumMap | EnumLiteral>;
+    lazyAlt?: Promise<EnumAlt>;
+}
+export type IgnoreFieldsByType<T, I> = {
+    [K in keyof T]: T[K] extends I ? K : never;
+}[keyof T];
+export type ReplaceType<T, O, N> = {
+    [P in keyof T]: T[P] extends O ? N : T[P];
+};
+export type SameType<A, T> = {
+    [K in keyof A]: T;
+};
+export type PickByType<T, I> = {
+    [K in keyof T]: T[K] extends I ? K : never;
+};
+export type PickKeyByType<T, I> = PickByType<T, I>[keyof T];
+export type OmitByType<T, I> = {
+    [K in keyof T]: T[K] extends I ? never : K;
+};
+export type OmitKeysByType<T, I> = OmitByType<T, I>[keyof T];
+export type ValueOrCallback<T> = T | ValueCallback<T> | ValueCallbackAsync<T>;
+export type ValueCallback<T> = () => T;
+export type ValueCallbackAsync<T> = () => Promise<T>;
+export type MaximumOneOf<T, K extends keyof T = keyof T> = K extends keyof T ? {
+    [P in K]: T[K];
+} & Partial<Record<Exclude<keyof T, K>, never>> : never;
+export type OneOf<Obj> = ValueOf<OneOfByKey<Obj>>;
+export type Xor<A, B> = XorIn<A & {
+    [K in keyof B]?: undefined;
+}> | XorIn<B & {
+    [K in keyof A]?: undefined;
+}>;
+type OneOnly<T, K extends keyof T> = Omit<T, Exclude<keyof T, K>> | Pick<T, K>;
+type OneOfByKey<T> = {
+    [key in keyof T]: OneOnly<T, key>;
+};
+type XorIn<T> = {
+    [K in keyof T]: T[K];
+} & unknown;
+/**
+ * JSON Object, record of `JsonValue`
+ *
+ * @see #JsonValue
+ */
+export type JsonObject = {
+    [K in string]?: JsonValue;
+};
+/**
+ * JSON Array, array of `JsonValue`
+ *
+ * @see #JsonValue
+ */
+export type JsonArray = Array<JsonValue>;
+/**
+ * JSON Primitive
+ *
+ * `OneOf`
+ * @see `string`
+ * @see `number`
+ * @see `boolean`
+ * @see `null`
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * JSON Value
+ *
+ * `OneOf`
+ * @see #JsonPrimitive
+ * @see #JsonObject
+ * @see #JsonArray
+ */
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type OptReason = 'invalid' | 'unexpected' | 'not:allowed' | 'not:found' | 'duplicated' | 'empty' | 'conflicted';
+export interface Opt<R extends string = string> extends Obj {
+    issue?: SetOrMore<OptReason | R | string>;
+    message?: SetOrMore<string>;
+    field?: string;
+    param?: SetOrMore<unknown>;
+    where?: SetOrMore<string>;
+    value?: SetOrMore<unknown>;
+    expected?: SetOrMore<ExtendedType | string>;
+    type?: SetOrMore<ExtendedType | string>;
+    method?: SetOrMore<string>;
+    case?: SetOrMore<unknown>;
+    desc?: SetOrMore<Describable | string>;
+    error?: SetOrMore<{
+        name: string;
+        message: string;
+    }>;
+    assert?: SetOrMore<string>;
+    [k: string]: unknown;
+}
+export type OptFn<O extends Opt = Opt> = () => O;
+export type OptAny<O extends Opt = Opt> = O | OptFn<O>;
+/**
+ * Extended array interface, ie: Clearable arrays
+ * */
+export interface ListLike<T = unknown> extends Array<T> {
+    /**
+     * Clears array items, to align all iteration repositories, like Set, Map etc
+     *
+     * @return {number} - returns deleted count
+     * */
+    clear(): number;
+    /**
+     * Deletes given item
+     *
+     * @param {any} value - will be deleted record
+     * @return {boolean} - is deleted?
+     * */
+    delete(value: T): boolean;
+    /**
+     * Deletes by given predicate
+     *
+     * @param {function} predicate - lambda expression
+     * @return {boolean} - is deleted?
+     * */
+    deleteByLambda(predicate: ListPredicate<T>): boolean;
+}
+export type ListPredicate<T = unknown> = (value: T, index?: number, arr?: Array<T>) => T;
+/**
+ * Bare omit error without any property
+ * */
+export type OmitError = Omit<Error, 'name' | 'message' | 'stack'>;
+export interface ErrorObject {
+    name: string;
+    message: string;
+}
+export interface ErrorItem extends ErrorDefineOpt {
+    name: string;
+    mode: LoaderMode;
+    clazz?: ClassLike;
+    lazyClass?: Promise<ClassLike>;
+}
+/**
+ * Stack line
+ * */
+export interface ErrorStackLine {
+    /**
+     * File of error
+     * */
+    file: string;
+    /**
+     * Method of error
+     * */
+    method?: string;
+    /**
+     * Position of error
+     * */
+    pos?: string;
+}
+export interface LeyyoStackLike extends Error {
+    /**
+     * Formatted stack trace
+     * */
+    stackTrace?: Array<ErrorStackLine>;
+}
+export interface LeyyoErrorLike extends Error, LeyyoStackLike, ShiftSecure<LeyyoErrorSecure> {
+    /**
+     * Parameters for error
+     * */
+    params?: Opt;
+    /**
+     * Caused error
+     * */
+    causedBy?: OneOrMore<Error>;
+    /**
+     * Bind caused error
+     *
+     * @param {Error} err
+     * @return {LeyyoErrorLike}
+     * */
+    causes(err: Error): this;
+    /**
+     * Bind holder class name
+     *
+     * @param {string} name - name of class
+     * @param {string?} fqn - fqn
+     * @return {LeyyoErrorLike}
+     * */
+    where(name: string, fqn?: string): this;
+    /**
+     * Bind holder instance
+     *
+     * @param {Obj} instance - this instance
+     * @return {LeyyoErrorLike}
+     * */
+    where(instance: Obj): this;
+    /**
+     * Bind holder instance
+     *
+     * @param {function} clazz - class
+     * @return {LeyyoErrorLike}
+     * */
+    where(clazz: ClassLike): this;
+    /**
+     * Alias for {@link logError}
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    log(logger?: Logger): void;
+    /**
+     * Log as `fatal`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logFatal(logger?: Logger): void;
+    /**
+     * Log as `error`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logError(logger?: Logger): void;
+    /**
+     * Log as `warn`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logWarn(logger?: Logger): void;
+    /**
+     * Log as `debug`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logDebug(logger?: Logger): void;
+    /**
+     * Log as `info`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logInfo(logger?: Logger): void;
+    /**
+     * Log as `trace`
+     *
+     * @param {Logger?} logger - optional bound logger
+     * */
+    logTrace(logger?: Logger): void;
+}
+export interface LeyyoErrorSecure extends ShiftMain<LeyyoErrorLike> {
+    /**
+     * List flags
+     *
+     * @return {Array<string>} - flags
+     * */
+    $list<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(): Array<T>;
+    /**
+     * Append a flag
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - is it appended?
+     * */
+    $append<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Remove a flag
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - is it removed?
+     * */
+    $remove<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Has a flag?
+     *
+     * @param {string} key - flag key
+     * @return {boolean} - has it?
+     * */
+    $has<T extends LeyyoErrorTag | string = LeyyoErrorTag | string>(key: T): boolean;
+    /**
+     * Copy source properties into target parameters
+     *
+     * @param {Error} source - source error
+     * */
+    $copyProperties(source: Error): void;
+}
+export type LeyyoErrorTag = 'printed' | 'sent';
+export interface ErrorDefineOpt {
+    /**
+     * Fqn name
+     * */
+    fqn?: string;
+    /**
+     * Default error message
+     * */
+    message?: string;
+    /**
+     * Will be error emitted?
+     * */
+    emit?: unknown;
+    /**
+     * Will be the error decorated for context language?
+     * */
+    i18n?: unknown;
+}
+export interface ErrorDefineEagerOpt extends ErrorDefineOpt {
+}
+export interface ErrorDefineLazyOpt extends ErrorDefineOpt {
+    name: string;
+    lazyClass: Promise<ClassLike>;
+}
+export type ErrorStackBuilder = (err: LeyyoStackLike, force?: boolean) => void;
+export type LifecycleStage = 'initialize' | 'print' | 'validate' | 'process' | 'clear' | 'ota-before' | 'ota-after' | 'kill';
+export type LifecycleTuple = [string, Array<Fnc>];
+export type LifecycleSortLambda = (map: Map<string, Array<Fnc>>) => Array<LifecycleTuple>;
+export type ExporterData = Record<string, ExporterValue>;
+export type ExporterValue = Record<string, unknown>;
+export interface ExporterDepot {
+    add(name: string, value: ExporterValue): void;
+}
+export interface Logger extends ShiftSecure<LoggerSecure> {
+    debug(message: string, params?: any | Opt): void;
+    debug(error: Error, params?: any | Opt): void;
+    debug(whatever: any, params?: any | Opt): void;
+    trace(message: string, params?: any | Opt): void;
+    trace(error: Error, params?: any | Opt): void;
+    trace(whatever: any, params?: any | Opt): void;
+    info(message: string, params?: any | Opt): void;
+    info(error: Error, params?: any | Opt): void;
+    info(whatever: any, params?: any | Opt): void;
+    warn(message: string, params?: any | Opt): void;
+    warn(error: Error, params?: any | Opt): void;
+    warn(whatever: any, params?: any | Opt): void;
+    error(message: string, params?: any | Opt): void;
+    error(error: Error, params?: any | Opt): void;
+    error(whatever: any, params?: any | Opt): void;
+    fatal(message: string, params?: any | Opt): void;
+    fatal(error: Error, params?: any | Opt): void;
+    fatal(whatever: any, params?: any | Opt): void;
+}
+export interface LoggerSecure extends ShiftMain<Logger> {
+    get $name(): string;
+    $refresh(level: LogLevel): void;
+}
+export interface LogItem {
+    level: LogLevel;
+    where?: string;
+    ctx?: unknown;
+    now: string;
+    message: string | Error;
+    params?: Opt;
+    paramStr?: string;
+}
+export type LocalColorLevel = [boolean, string, string];
+export interface LocalColorLike {
+    bold: string;
+    normal: string;
+    end: string;
+    param: string;
+    levels: Record<LogLevel, LocalColorLevel>;
+}
+export type LogFormatterLambda = (item: LogItem) => void;
+export type LogConsumerLambda = (item: LogItem) => void;
+export type LogStylerLambda = (item: LogItem) => string;
+export type ContextFinderLambda = <T = unknown>(...p: Array<unknown>) => T;
+export type LoaderMode = 'eager' | 'lazy';
+export type LoaderLike = Array<LoaderItem>;
+export type LeyyoStampLambda = () => LoaderItem;
+export type LeyyoStampEmpty = () => symbol;
+export type LoaderItem = ClassLike | Fnc | EnumMap | EnumLiteral | Obj | LeyyoStampLambda | LeyyoStampEmpty | LoaderLike;
+export type EventType = 'log' | 'error:emit' | 'context:finder';
+export {};

package/dist/{shared/index.types.js → index.types.js}

@@ -1,7 +1,7 @@
 "use strict";
 // noinspection JSUnusedGlobalSymbols
 Object.defineProperty(exports, "__esModule", { value: true });
-// endregion
+// endregion event
 /*
 
 // export type StrObject<T> = {

package/dist/index.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.types.js","sourceRoot":"","sources":["../src/index.types.ts"],"names":[],"mappings":";AAAA,qCAAqC;;AA6oBrC,kBAAkB;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BE"}

package/dist/loader.d.ts

@@ -0,0 +1,2 @@
+export declare const loader_leyyoCommon: import("./index.types").LoaderLike;
+export declare const foretell_leyyoCommon: (() => void)[];

package/dist/loader.js

@@ -0,0 +1,98 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foretell_leyyoCommon = exports.loader_leyyoCommon = void 0;
+const internal_1 = require("./internal");
+const common_1 = require("./common");
+// noinspection JSUnusedGlobalSymbols
+exports.loader_leyyoCommon = (0, common_1.defineLoader)(internal_1.FQN, 
+// errors
+() => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError), () => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.DeveloperError), () => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.HttpError), () => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.InvalidValueError), () => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.LeyyoError), () => Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.MultipleError), 
+// enums
+() => Promise.resolve().then(() => __importStar(require('./enum'))).then(m => m.LogLevelItems), 
+// classes
+() => Promise.resolve().then(() => __importStar(require('./class'))).then(m => m.List), () => Promise.resolve().then(() => __importStar(require('./class'))).then(m => m.LoggerInstance));
+// noinspection JSUnusedGlobalSymbols
+exports.foretell_leyyoCommon = [
+    () => (0, common_1.defineLazyError)({
+        name: 'CausedError',
+        fqn: internal_1.FQN,
+        i18n: true,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError)
+    }),
+    () => (0, common_1.defineLazyError)({
+        name: 'DeveloperError',
+        fqn: internal_1.FQN,
+        i18n: false,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.DeveloperError)
+    }),
+    () => (0, common_1.defineLazyError)({
+        name: 'CausedError',
+        fqn: internal_1.FQN,
+        i18n: true,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError)
+    }),
+    () => (0, common_1.defineLazyError)({
+        name: 'CausedError',
+        fqn: internal_1.FQN,
+        i18n: true,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError)
+    }),
+    () => (0, common_1.defineLazyError)({
+        name: 'CausedError',
+        fqn: internal_1.FQN,
+        i18n: true,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError)
+    }),
+    () => (0, common_1.defineLazyError)({
+        name: 'CausedError',
+        fqn: internal_1.FQN,
+        i18n: true,
+        emit: true,
+        lazyClass: Promise.resolve().then(() => __importStar(require('./error'))).then(m => m.CausedError)
+    }),
+    () => (0, common_1.defineLazyEnum)({
+        name: 'LogLevel',
+        fqn: internal_1.FQN,
+        i18n: true,
+        lazyData: Promise.resolve().then(() => __importStar(require('./enum'))).then(m => m.LogLevelItems)
+    })
+];
+//# sourceMappingURL=loader.js.map

package/dist/loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.js","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yCAA+B;AAC/B,qCAAuE;AAEvE,qCAAqC;AACxB,QAAA,kBAAkB,GAAG,IAAA,qBAAY,EAAC,cAAG;AAC9C,SAAS;AACT,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,EAChD,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,EACnD,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,EAC9C,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,iBAAiB,CAAC,EACtD,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,EAC/C,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;AAClD,QAAQ;AACR,GAAG,EAAE,CAAC,kDAAO,QAAQ,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;AACjD,UAAU;AACV,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EACzC,GAAG,EAAE,CAAC,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,CACtD,CAAC;AAEF,qCAAqC;AACxB,QAAA,oBAAoB,GAAG;IAChC,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;KAAC,CACzD;IACD,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,gBAAgB;QACtB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC;KAAC,CAC5D;IACD,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;KAAC,CACzD;IACD,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;KAAC,CACzD;IACD,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;KAAC,CACzD;IACD,GAAG,EAAE,CAAC,IAAA,wBAAe,EAAC;QAClB,IAAI,EAAE,aAAa;QACnB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,IAAI,EAAE,IAAI;QACV,SAAS,EAAE,kDAAO,SAAS,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;KAAC,CACzD;IAED,GAAG,EAAE,CAAC,IAAA,uBAAc,EAAC;QACjB,IAAI,EAAE,UAAU;QAChB,GAAG,EAAE,cAAG;QACR,IAAI,EAAE,IAAI;QACV,QAAQ,EAAE,kDAAO,QAAQ,IAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC;KAAC,CACzD;CACJ,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@leyyo/common",
-  "version": "1.2.6",
-  "description": "Common library",
+  "version": "1.3.1",
+  "description": "Leyyo common library",
   "keywords": [
     "common"
   ],
@@ -22,7 +22,7 @@
     "lint": "eslint src/**/*.ts",
     "asset": "node -r ts-node/register commands/assets.ts",
     "build": "npm run clear && tsc && npm run asset",
-    "test": "jest --config=jest.json --verbose",
+    "test": "npx jest --config=jest.json --clearCache && npx jest --config=jest.json --verbose",
     "test:watch": "jest --watch --config=jest.json",
     "test:coverage": "jest --config=jest.json --coverage --coverageDirectory=coverage",
     "~publish": "npm run build && npm publish -access=public"
@@ -33,6 +33,8 @@
   "license": "ISC",
   "devDependencies": {
     "@babel/preset-typescript": "^7.27.0",
+    "@types/express": "^5.0.6",
+    "@types/geoip-lite": "^1.4.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.14.0",
     "@typescript-eslint/eslint-plugin": "^8.29.0",

package/dist/$$leyyo-loader.d.ts

@@ -1 +0,0 @@
-export declare const $$leyyoLoader: import("./shared").LoaderLike;