@leyyo/common 1.0.0 → 1.0.1

package/dist/is/common-is-impl.js

@@ -3,62 +3,87 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommonIsImpl = void 0;
 const literals_1 = require("../literals");
 // noinspection JSUnusedGlobalSymbols, JSUnusedLocalSymbols
+/** @inheritDoc */
 class CommonIsImpl {
-    $init(leyyo) {
-    }
     // region is
+    /** @inheritDoc */
     empty(value) {
-        return (value === undefined || value === null);
+        return (value === undefined || value === null || (typeof value === 'string' && value.trim() === ''));
     }
+    /** @inheritDoc */
     primitive(value) {
         return literals_1.PrimitiveItems.includes((typeof value));
     }
-    value(value) {
+    /** @inheritDoc */
+    realValue(value) {
         return literals_1.RealValueItems.includes((typeof value));
     }
+    /** @inheritDoc */
     key(value) {
         return literals_1.KeyValueItems.includes((typeof value));
     }
+    /** @inheritDoc */
     object(value) {
         return value && typeof value === 'object' && !Array.isArray(value);
     }
+    /** @inheritDoc */
     array(value) {
         return value && typeof value === 'object' && Array.isArray(value);
     }
+    /** @inheritDoc */
     func(value) {
         return typeof value === 'function';
     }
+    /** @inheritDoc */
     number(value) {
         return (typeof value === 'number') && !isNaN(value) && isFinite(value);
     }
+    /** @inheritDoc */
     integer(value) {
+        return this.number(value) && Number.isInteger(value);
+    }
+    /** @inheritDoc */
+    safeInteger(value) {
         return this.number(value) && Number.isSafeInteger(value);
     }
+    /** @inheritDoc */
     string(value) {
         return typeof value === 'string';
     }
+    /** @inheritDoc */
     text(value) {
         return this.string(value) && value.trim() !== '';
     }
+    /** @inheritDoc */
     clazz(value) {
         return this.text(value) || this.func(value) || this.object(value);
     }
+    /** @inheritDoc */
     boolean(value) {
         return (typeof value === 'boolean');
     }
+    /** @inheritDoc */
     true(value) {
         return (value === true) ||
             (this.text(value) && literals_1.WeakTrueItems.includes(value.toLowerCase())) ||
             (this.number(value) && value > 0);
     }
+    /** @inheritDoc */
     false(value) {
         return (value === false) ||
             (this.text(value) && literals_1.WeakFalseItems.includes(value.toLowerCase())) ||
             (this.number(value) && value <= 0);
     }
+    // endregion is
+    // region secure
+    /** @inheritDoc */
+    $init(leyyo) {
+    }
+    /** @inheritDoc */
     get $back() {
         return this;
     }
+    /** @inheritDoc */
     get $secure() {
         return this;
     }

package/dist/is/index-types.d.ts

@@ -1,22 +1,145 @@
-import { ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
+import { InitLike, ShiftMain, ShiftSecure } from "../aliases";
+/**
+ * Basic is commands to easy use
+ * */
 export interface CommonIs extends ShiftSecure<CommonIsSecure> {
-    empty(value: unknown): boolean;
-    primitive(value: unknown): boolean;
-    value(value: unknown): boolean;
-    key(value: unknown): boolean;
-    object(value: unknown): boolean;
-    array(value: unknown): boolean;
-    func(value: unknown): boolean;
-    number(value: unknown): boolean;
-    integer(value: unknown): boolean;
-    string(value: unknown): boolean;
-    text(value: unknown): boolean;
-    clazz(value: unknown): boolean;
-    boolean(value: unknown): boolean;
-    true(value: unknown): boolean;
-    false(value: unknown): boolean;
+    /**
+     * Checks value is empty or not?
+     * Empty means: `undefined`, `null` or `empty string` after trimming
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    empty(value: any): boolean;
+    /**
+     * Checks value is primitive or not?
+     * Primitive means: `string`, `number`, `boolean`
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    primitive(value: any): boolean;
+    /**
+     * Checks value is real value or not?
+     * Real value means: `string`, `number`, `bigint`, `boolean`, `object`, `function`
+     * So `symbol` is not a real value
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    realValue(value: any): boolean;
+    /**
+     * Checks value is key or not?
+     * Key means: `string`, `number`
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    key(value: any): boolean;
+    /**
+     * Checks value is object or not?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    object(value: any): boolean;
+    /**
+     * Checks value is array or not?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    array(value: any): boolean;
+    /**
+     * Checks value is function or not?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    func(value: any): boolean;
+    /**
+     * Checks value is number (float or integer) or not?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     *
+     * Note: NaN and infinite values are not evaluated as a number
+     * */
+    number(value: any): boolean;
+    /**
+     * Checks value is integer or not?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     *
+     * Note: NaN and infinite values are not evaluated as a number
+     * */
+    integer(value: any): boolean;
+    /**
+     * Checks value is safe integer or not?
+     * Safe integer means: an integer can not be outside the bigint range
+     *
+     * @param {any} value
+     * @returns {boolean}
+     *
+     * Note: NaN and infinite values are not evaluated as a number
+     * */
+    safeInteger(value: any): boolean;
+    /**
+     * Checks value is string or not?
+     * Empty string or space values are also string, if you want different behaviour, please check {@link #text}
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    string(value: any): boolean;
+    /**
+     * Checks value is string which is can not be empty and spaced?
+     * Empty string or space values are not a text, if you want different behaviour, please check {@link #string}
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    text(value: any): boolean;
+    /**
+     * Checks value is possible class?
+     * Possible class means: object as instance, string as function name, or function
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    clazz(value: any): boolean;
+    /**
+     * Checks value is boolean?
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    boolean(value: any): boolean;
+    /**
+     * Checks value is possible true?
+     *
+     * Possible true means:
+     * - boolean: true
+     * - string: `1`, `true`, `t`, `yes`, `y`, `on`
+     * - number: > 0 (positive)
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    true(value: any): boolean;
+    /**
+     * Checks value is possible false?
+     *
+     * Possible false means:
+     * - boolean: false
+     * - string: `0`, `-1`, `false`, `f`, `no`, `n`, `off`
+     * - number: <= 0 (zero or negative)
+     *
+     * @param {any} value
+     * @returns {boolean}
+     * */
+    false(value: any): boolean;
 }
-export interface CommonIsSecure extends ShiftMain<CommonIs> {
-    $init(leyyo: Leyyo): void;
+export interface CommonIsSecure extends ShiftMain<CommonIs>, InitLike {
 }

package/dist/leyyo/leyyo-impl.js

@@ -59,7 +59,7 @@ class LeyyoImpl {
         });
     }
     initEnumRegister() {
-        [literals_1.PrimitiveItems, literals_1.RealValueItems, literals_1.KeyValueItems, literals_1.WeakTrueItems, literals_1.WeakFalseItems,
+        [literals_1.PrimitiveItems, literals_1.StorageTypeItems, literals_1.RealValueItems, literals_1.KeyValueItems, literals_1.WeakTrueItems, literals_1.WeakFalseItems,
             literals_1.HttpMethodItems, literals_1.HttpPlaceItems, literals_1.SeverityItems, literals_1.EnvironmentItems,
             literals_1.CountryCodeItems, literals_1.LanguageCodeItems, literals_1.LocaleCodeItems].forEach(enm => {
             this.callback.queueForCallback(constants_1.LY_PENDING_FQN_REGISTER, enm, 'enum', internal_1.FQN_PCK);

package/dist/literals.d.ts

@@ -1,7 +1,15 @@
 /**
  * Weak True items
  * */
-export declare const PrimitiveItems: readonly ["string", "number", "bigint", "boolean"];
+export declare const StorageTypeItems: readonly ["array", "list", "map", "set"];
+/**
+ * Storage type literal, as an enum
+ * */
+export type StorageType = typeof StorageTypeItems[number];
+/**
+ * Weak True items
+ * */
+export declare const PrimitiveItems: readonly ["string", "number", "boolean"];
 /**
  * Weak True
  * */

package/dist/literals.js

@@ -1,11 +1,15 @@
 "use strict";
-// noinspection JSUnusedGlobalSymbols
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocaleCodeItems = exports.LanguageCodeItems = exports.CountryCodeItems = exports.EnvironmentItems = exports.SeverityItems = exports.HttpPlaceItems = exports.HttpMethodItems = exports.WeakFalseItems = exports.WeakTrueItems = exports.KeyValueItems = exports.RealValueItems = exports.PrimitiveItems = void 0;
+exports.LocaleCodeItems = exports.LanguageCodeItems = exports.CountryCodeItems = exports.EnvironmentItems = exports.SeverityItems = exports.HttpPlaceItems = exports.HttpMethodItems = exports.WeakFalseItems = exports.WeakTrueItems = exports.KeyValueItems = exports.RealValueItems = exports.PrimitiveItems = exports.StorageTypeItems = void 0;
+// noinspection JSUnusedGlobalSymbols
+/**
+ * Weak True items
+ * */
+exports.StorageTypeItems = ['array', 'list', 'map', 'set'];
 /**
  * Weak True items
  * */
-exports.PrimitiveItems = ['string', 'number', 'bigint', 'boolean'];
+exports.PrimitiveItems = ['string', 'number', 'boolean'];
 /**
  * Weak True items
  * */

package/dist/log/index-types.d.ts

@@ -1,6 +1,5 @@
-import { Leyyo } from "../leyyo";
 import { Severity } from "../literals";
-import { Dict, ShiftMain, ShiftSecure } from "../aliases";
+import { Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
 import { CommonCallbackDefined } from "../callback";
 export interface CommonLog extends ShiftSecure<CommonLogSecure>, LogConsumer {
     create(clazz: Object | Function | string): Logger;
@@ -11,8 +10,7 @@ export interface CommonLogCb extends CommonCallbackDefined {
     check?<T>(line: LogLineEnhanced<T>): void;
     print<T>(line: LogLineEnhanced<T>): void;
 }
-export interface CommonLogSecure extends ShiftMain<CommonLog> {
-    $init(leyyo: Leyyo): void;
+export interface CommonLogSecure extends ShiftMain<CommonLog>, InitLike {
 }
 export interface LogConsumer {
     apply(line: LogLine): void;
@@ -47,12 +45,11 @@ export interface Logger extends ShiftSecure<LoggerSecure> {
     debug(error: Error, params?: any): void;
     debug(whatever: any, params?: any): void;
 }
-export type LogMethod = 'error' | 'warn' | 'info' | 'log' | 'trace' | 'debug';
 export interface LoggerSecure extends ShiftMain<Logger> {
     get $clazz(): Function;
     get $name(): string;
     $assert(error: Error, indicator: string, params?: unknown): void;
     $setName(name: string): void;
-    $setMethod(method: LogMethod, lambda?: LoggerLambda): void;
+    $setMethod(method: Severity, lambda?: LoggerLambda): void;
 }
 export type LoggerLambda = (whatever: any, params?: any) => void;

package/dist/log/logger-impl.d.ts

@@ -1,5 +1,6 @@
-import { Logger, LoggerLambda, LoggerSecure, LogMethod } from "./index-types";
+import { Logger, LoggerLambda, LoggerSecure } from "./index-types";
 import { Leyyo } from "../leyyo";
+import { Severity } from "../literals";
 export declare class LoggerImpl implements Logger, LoggerSecure {
     private readonly _clazz;
     private _name;
@@ -18,6 +19,6 @@ export declare class LoggerImpl implements Logger, LoggerSecure {
     get $name(): string;
     static $setLeyyo(leyyo: Leyyo): void;
     $setName(name: string): void;
-    $setMethod(method: LogMethod, lambda?: LoggerLambda): void;
+    $setMethod(method: Severity, lambda?: LoggerLambda): void;
     $assert(error: Error, indicator: string, params?: unknown): void;
 }

package/dist/log/logger-impl.js

@@ -64,7 +64,8 @@ class LoggerImpl {
             this[method] = lambda;
         }
         else {
-            this[method] = () => { };
+            this[method] = () => {
+            };
         }
     }
     $assert(error, indicator, params) {

package/dist/storage/common-storage-impl.d.ts

@@ -1,6 +1,7 @@
 import { List } from "./list";
-import { CommonStorage, CommonStorageSecure, StorageDetail, StorageItem, StorageType } from "./index-types";
+import { CommonStorage, CommonStorageSecure, StorageDetail, StorageItem } from "./index-types";
 import { Leyyo } from "../leyyo";
+import { StorageType } from "../literals";
 /** @inheritDoc */
 export declare class CommonStorageImpl implements CommonStorage, CommonStorageSecure {
     private readonly _lists;

package/dist/storage/index-types.d.ts

@@ -1,6 +1,6 @@
 import { List } from "./list";
-import { Dict, ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
+import { Dict, InitLike, ShiftMain, ShiftSecure } from "../aliases";
+import { StorageType } from "../literals";
 /**
  * Storage factory
  *
@@ -85,13 +85,8 @@ export interface CommonStorage extends ShiftSecure<CommonStorageSecure> {
      * */
     details(type?: StorageType, name?: string): StorageDetail;
 }
-export interface CommonStorageSecure extends ShiftMain<CommonStorage> {
-    $init(leyyo: Leyyo): void;
+export interface CommonStorageSecure extends ShiftMain<CommonStorage>, InitLike {
 }
-/**
- * Storage type literal, as an enum
- * */
-export type StorageType = 'array' | 'list' | 'map' | 'set';
 /**
  * Storage size dictionary which in corresponding type
  * */

package/dist/to/common-to-impl.d.ts

@@ -1,4 +1,4 @@
-import { CommonTo, CommonToSecure, TypeArrayOpt, TypeEnumOpt, TypeObjectOpt, TypeOpt } from "./index-types";
+import { CommonTo, CommonToSecure, ToTypeArrayOpt, ToTypeEnumOpt, ToTypeObjectOpt, ToTypeOpt } from "./index-types";
 import { Dict, KeyValue, OneOrMore } from "../aliases";
 import { Leyyo } from "../leyyo";
 export declare class CommonToImpl implements CommonTo, CommonToSecure {
@@ -16,22 +16,22 @@ export declare class CommonToImpl implements CommonTo, CommonToSecure {
     private _enumInMap;
     private _enumInArray;
     private _enumInAlteration;
-    runFn<T = unknown>(fn: Function, value: Function, opt?: TypeOpt): T;
-    runSave<T = unknown>(fn: Function, value: unknown, opt?: TypeOpt): T;
-    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: TypeOpt, params?: Dict): T;
-    any(value: unknown, opt?: TypeOpt): unknown;
-    array<T = unknown>(value: unknown, opt?: TypeArrayOpt): Array<T>;
-    boolean(value: unknown, opt?: TypeOpt): boolean;
-    clazz(value: unknown, opt?: TypeOpt): string;
-    date(value: unknown, opt?: TypeOpt): Date;
-    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: TypeEnumOpt<T>): T;
-    float(value: unknown, opt?: TypeOpt): number | null;
-    func<T = Function>(value: unknown, opt?: TypeOpt): T | null;
-    integer(value: unknown, opt?: TypeOpt): number | null;
-    object<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    dict<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    string(value: unknown, opt?: TypeOpt): string;
-    text(value: unknown, opt?: TypeOpt): string;
+    runFn<T = unknown>(fn: Function, value: Function, opt?: ToTypeOpt): T;
+    runSave<T = unknown>(fn: Function, value: unknown, opt?: ToTypeOpt): T;
+    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: ToTypeOpt, params?: Dict): T;
+    any(value: unknown, opt?: ToTypeOpt): unknown;
+    array<T = unknown>(value: unknown, opt?: ToTypeArrayOpt): Array<T>;
+    boolean(value: unknown, opt?: ToTypeOpt): boolean;
+    clazz(value: unknown, opt?: ToTypeOpt): string;
+    date(value: unknown, opt?: ToTypeOpt): Date;
+    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: ToTypeEnumOpt<T>): T;
+    float(value: unknown, opt?: ToTypeOpt): number | null;
+    func<T = Function>(value: unknown, opt?: ToTypeOpt): T | null;
+    integer(value: unknown, opt?: ToTypeOpt): number | null;
+    object<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    dict<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    string(value: unknown, opt?: ToTypeOpt): string;
+    text(value: unknown, opt?: ToTypeOpt): string;
     $init(leyyo: Leyyo): void;
     get $back(): CommonTo;
     get $secure(): CommonToSecure;

package/dist/to/index-types.d.ts

@@ -1,50 +1,49 @@
-import { Dict, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
-import { Leyyo } from "../leyyo";
+import { Dict, InitLike, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
 import { AssertionOpt } from "../assertion";
 export interface CommonTo extends ShiftSecure<CommonToSecure> {
-    runFn<T = unknown>(fn: Function, value: Function, opt?: TypeOpt): T;
-    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: TypeOpt, params?: Dict): T;
-    any(value: unknown, opt?: TypeOpt): unknown;
-    array<T = unknown>(value: unknown, opt?: TypeArrayOpt): Array<T>;
-    boolean(value: unknown, opt?: TypeOpt): boolean;
-    clazz(value: unknown, opt?: TypeOpt): string;
-    date(value: unknown, opt?: TypeOpt): Date;
-    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: TypeEnumOpt<T>): T;
-    float(value: unknown, opt?: TypeOpt): number | null;
-    func<T = Function>(value: unknown, opt?: TypeOpt): T | null;
-    integer(value: unknown, opt?: TypeOpt): number | null;
-    object<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    dict<T = unknown>(value: unknown, opt?: TypeObjectOpt): Dict<T>;
-    string(value: unknown, opt?: TypeOpt): string;
-    text(value: unknown, opt?: TypeOpt): string;
-}
-export interface CommonToSecure extends ShiftMain<CommonTo> {
-    $init(leyyo: Leyyo): void;
-}
-export interface TypeOpt extends AssertionOpt {
+    runFn<T = unknown>(fn: Function, value: Function, opt?: ToTypeOpt): T;
+    raiseInvalidValue<T = unknown>(value: unknown, expected: OneOrMore<string>, opt?: ToTypeOpt, params?: Dict): T;
+    any(value: unknown, opt?: ToTypeOpt): unknown;
+    array<T = unknown>(value: unknown, opt?: ToTypeArrayOpt): Array<T>;
+    boolean(value: unknown, opt?: ToTypeOpt): boolean;
+    clazz(value: unknown, opt?: ToTypeOpt): string;
+    date(value: unknown, opt?: ToTypeOpt): Date;
+    enumeration<T extends KeyValue = KeyValue>(value: unknown, opt?: ToTypeEnumOpt<T>): T;
+    float(value: unknown, opt?: ToTypeOpt): number | null;
+    func<T = Function>(value: unknown, opt?: ToTypeOpt): T | null;
+    integer(value: unknown, opt?: ToTypeOpt): number | null;
+    object<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    dict<T = unknown>(value: unknown, opt?: ToTypeObjectOpt): Dict<T>;
+    string(value: unknown, opt?: ToTypeOpt): string;
+    text(value: unknown, opt?: ToTypeOpt): string;
+}
+export interface CommonToSecure extends ShiftMain<CommonTo>, InitLike {
+}
+export interface ToTypeOpt extends AssertionOpt {
     silent?: true;
     children?: unknown;
 }
-export type TypeFnLambda<T = unknown, O extends TypeOpt = TypeOpt> = (value: unknown, opt?: O) => T;
-export interface TypeChildOpt<T = unknown> extends TypeOpt {
-    fn?: TypeFnLambda<T>;
+export type ToTypeFnLambda<T = unknown, O extends ToTypeOpt = ToTypeOpt> = (value: unknown, opt?: O) => T;
+export interface ToTypeChildOpt<T = unknown> extends ToTypeOpt {
+    fn?: ToTypeFnLambda<T>;
 }
-export interface TypeArrayChildOpt<V extends TypeChildOpt = TypeChildOpt> extends Dict<TypeChildOpt> {
+export interface ToTypeArrayChildOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends Dict<ToTypeChildOpt> {
     value?: V;
 }
-export interface TypeArrayOpt<V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
-    children?: TypeArrayChildOpt<V>;
+export interface ToTypeArrayOpt<V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeArrayChildOpt<V>;
 }
-export interface TypeDictChildOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends Record<string, TypeChildOpt> {
+export interface ToTypeDictChildOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends Record<string, ToTypeChildOpt> {
     key?: K;
     value?: V;
 }
-export interface TypeObjectOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
-    children?: TypeDictChildOpt<K, V>;
+export interface ToTypeObjectOpt<K extends ToTypeChildOpt = ToTypeChildOpt, V extends ToTypeChildOpt = ToTypeChildOpt> extends ToTypeOpt {
+    children?: ToTypeDictChildOpt<K, V>;
 }
-export interface TypeEnumOpt<E extends KeyValue = KeyValue> extends TypeOpt {
-    map: EnumerationMap<E>;
+export interface ToTypeEnumOpt<E extends KeyValue = KeyValue> extends ToTypeOpt {
+    map: EnumerationMap<E> | EnumerationArray<E>;
     alt?: EnumerationAlt<E>;
 }
 export type EnumerationMap<E extends KeyValue = KeyValue> = Dict<E>;
 export type EnumerationAlt<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationArray<E extends KeyValue = KeyValue> = Array<E>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leyyo/common",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Common library",
   "keywords": [
     "common"