@leyyo/common 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Mustafa Yelmer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,25 @@
+# Leyyo Common
+Common library for Leyyo framework
+
+## Import
+- `npm i @leyyo/common`
+
+## Standards
+- Language: `TS`
+- Eslint: `Yes`
+- Static Code Analysis: `Yes` *IntelliJ Code Inspections*
+- DDD - Document Driven: `Yes`
+- DDD - Domain Driven: `Yes`
+- EDD - Exception Driven: `Yes`
+- TDD - Test Driven: `Yes`
+- LDD - Log Driven: `Yes`
+- 12FA - 12 Factor-App: `50%` *Partially*
+
+## Dependencies
+### NO
+
+---
+### Prepared by
+- Mustafa Yelmer
+- mustafayelmer(at)gmail.com
+- `2025-01-10`

package/dist/aliases.d.ts

@@ -0,0 +1,139 @@
+import { LanguageCode, LocaleCode } from "./literals";
+export type BasicType = 'undefined' | 'string' | 'object' | 'number' | 'boolean' | 'function' | 'symbol' | 'bigint';
+export type Dict<T = any> = Record<KeyValue, T>;
+export type Arr<T = any> = Array<T>;
+export type KeyValue = string | number;
+export type Id = string | number;
+export type Unknown = unknown;
+export type Integer = number;
+export type Float = number;
+export type Boolean = boolean;
+export type Enum = string;
+export type Alpha = string;
+export type String = 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;
+interface _Func {
+    readonly name?: string;
+    readonly length?: number;
+    bind(thisArg: any, ...args: Array<any>): any;
+    apply(thisArg: any, args: Array<any>): any;
+    call(thisArg: any, ...args: Array<any>): any;
+}
+export interface Fnc<R = any> extends _Func {
+    (...args: Array<any>): R;
+}
+export interface AsyncFnc<R = any> extends _Func {
+    (...args: Array<any>): Promise<R>;
+}
+export type Func<R = any> = Function | Fnc<R>;
+export type Async<R = any> = Function | AsyncFnc<R>;
+export interface ClassLike<T = {}> extends _Func {
+    new (...args: Array<any>): T;
+}
+/**
+ * Serialized version of another type
+ */
+export type Serialized<T> = {
+    [P in keyof T]: T[P];
+};
+export type ClassOrName = ClassLike | string;
+export type FuncOrName = Function | string;
+/**
+ * Referenced from Object
+ * */
+export type Obj = Object & {};
+export interface Abstract<T> extends Function {
+    prototype: T;
+}
+export interface Entity<I extends Id = Uuid> {
+    id?: I;
+}
+export interface Pair<I extends Id = Uuid> extends Entity<I> {
+    name?: string;
+}
+export type TypeOfMethod<T, M extends keyof T> = T[M] extends Function ? T[M] : never;
+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 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;
+}>;
+export type Mutable<A> = {
+    -readonly [K in keyof A]: A[K];
+};
+export type OneOrMore<T> = T | Array<T>;
+export type SameType<A, T> = {
+    [K in keyof A]: T;
+};
+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;
+export interface ShiftSecure<S extends ShiftMain<any>> {
+    get $secure(): S;
+}
+export interface ShiftFlat<D> {
+    get $flat(): D;
+}
+export interface ShiftMain<M extends ShiftSecure<any>> {
+    get $back(): M;
+}
+export interface InitLike {
+    $init(...args: Arr): void;
+}
+/**
+ * JSON Object
+ */
+export type JsonObject = {
+    [K in string]?: JsonValue;
+};
+/**
+ * JSON Array
+ */
+export type JsonArray = Array<JsonValue>;
+/**
+ * JSON Primitives
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * JSON Values
+ */
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+/**
+ * Primitive language key
+ *
+ * It can be language (xx), local (xx-xx) or string (not preferred)
+ * */
+export type I18nKey = LanguageCode | LocaleCode | string;
+/**
+ * Language map
+ *
+ * @example
+ * const name = {en: "Apple", tr: "Elma"};
+ *
+ * */
+export type I18nRaw<V = unknown> = Dict<V>;
+export type I18nAny<V = unknown> = I18nRaw<V> | V;
+export {};

package/dist/aliases.js

@@ -0,0 +1,4 @@
+"use strict";
+// noinspection JSUnusedGlobalSymbols
+Object.defineProperty(exports, "__esModule", { value: true });
+// endregion i18n

package/dist/assertion/assert.d.ts

@@ -0,0 +1,6 @@
+import { AssertionOpt } from "./index-types";
+import { Leyyo } from "../leyyo";
+export declare function assert(flag: boolean, message?: string): void;
+export declare function assert(flag: boolean, opt?: AssertionOpt): void;
+export declare function assert(flag: boolean, fn?: Function): void;
+export declare function $$setLeyyo(leyyo: Leyyo): void;

package/dist/assertion/assert.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+exports.$$setLeyyo = $$setLeyyo;
+let assertion;
+function assert(flag, v2) {
+    if (!flag) {
+        assertion.raise(v2);
+    }
+}
+function $$setLeyyo(leyyo) {
+    assertion = leyyo.assertion;
+}

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

@@ -0,0 +1,34 @@
+import { AssertionCallback, AssertionOpt, CommonAssertion, CommonAssertionSecure } from "./index-types";
+import { Leyyo } from "../leyyo";
+import { TypeOpt } from "../to";
+import { Arr, Obj } from "../aliases";
+export declare class CommonAssertionImpl implements CommonAssertion, CommonAssertionSecure {
+    private is;
+    private callback;
+    constructor();
+    private buildMessage;
+    _secureJson(value: unknown, level: number, set: WeakSet<Obj>): unknown;
+    raise(opt: string | AssertionOpt | AssertionCallback, value?: any, indicator?: string, def?: string): void;
+    emptyFn(...params: Arr): void;
+    secureJson<E = unknown>(value: unknown): E;
+    realNumber(value: number, opt?: TypeOpt): number;
+    array(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    boolean(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    clazz(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    date(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    func(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    integer(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    key(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    notEmpty(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    number(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    object(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    positiveInteger(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    positiveNumber(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    primitive(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    string(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    text(value: unknown, opt?: string | AssertionOpt | AssertionCallback): string;
+    value(value: unknown, opt?: string | AssertionOpt | AssertionCallback): void;
+    get $back(): CommonAssertion;
+    $init(leyyo: Leyyo): void;
+    get $secure(): CommonAssertionSecure;
+}

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

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonAssertionImpl = void 0;
+const error_1 = require("../error");
+class CommonAssertionImpl {
+    // endregion properties
+    constructor() {
+    }
+    // region internal
+    buildMessage(v2, indicator) {
+        if (typeof v2 === 'string') {
+            return { message: v2, params: { indicator } };
+        }
+        if (v2 && typeof v2 === 'object' && !Array.isArray(v2)) {
+            const params = v2;
+            if (params.indicator !== undefined) {
+                params.indicator2 = params.indicator;
+                params.indicator = indicator;
+            }
+            return { params };
+        }
+        if (typeof v2 === 'function') {
+            try {
+                return this.buildMessage(v2(), indicator);
+            }
+            catch (e) {
+                return { params: { indicator, callbackError: e.message } };
+            }
+        }
+        if (v2 === null || v2 === undefined) {
+            return { params: { indicator } };
+        }
+        const json = this.secureJson(v2);
+        if (json && typeof json === 'object' && !Array.isArray(json)) {
+            return { params: Object.assign(Object.assign({}, json), { indicator }) };
+        }
+        return { params: { json, indicator } };
+    }
+    _secureJson(value, level, set) {
+        if ([null, undefined].includes(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'object':
+                if (set.has(value)) {
+                    return `<circular>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                }
+                if (level >= 10) {
+                    return `<max-depth>${this.callback.fqnName(value === null || value === void 0 ? void 0 : value.constructor)}`;
+                }
+                set.add(value);
+                if (Array.isArray(value)) {
+                    return value.map(item => this._secureJson(item, level + 1, set));
+                }
+                const obj = {};
+                if (value instanceof Map) {
+                    for (const [k, v] of value.entries()) {
+                        obj[k] = JSON.parse(JSON.stringify(this._secureJson(v, level + 1, set)));
+                    }
+                }
+                else if (value instanceof Set) {
+                    return Array.from(value).map(item => this._secureJson(item, level + 1, set));
+                }
+                else {
+                    for (const [k, v] of Object.entries(value)) {
+                        obj[k] = JSON.parse(JSON.stringify(this._secureJson(v, level + 1, set)));
+                    }
+                }
+                return obj;
+            case 'function':
+                return `<function>${this.callback.fqnName(value)}`;
+            case 'symbol':
+                return `<symbol>${value.toString()}`;
+        }
+        return value;
+    }
+    // endregion internal
+    // region raise
+    raise(opt, value, indicator, def) {
+        const { message, params } = this.buildMessage(opt, indicator);
+        const type = typeof value;
+        switch (type) {
+            case "object":
+                params.type = `object(${this.callback.fqnName(value.constructor)})`;
+                break;
+            case "function":
+                params.type = `function(${this.callback.fqnName(value)})`;
+                break;
+            default:
+                params.type = type;
+                break;
+        }
+        def = def !== null && def !== void 0 ? def : 'Assertion error';
+        throw new error_1.AssertionException(message !== null && message !== void 0 ? message : def, params);
+    }
+    // noinspection JSUnusedLocalSymbols
+    emptyFn(...params) { }
+    secureJson(value) {
+        return this._secureJson(value, 0, new WeakSet());
+    }
+    realNumber(value, opt) {
+        if (isNaN(value) || !isFinite(value)) {
+            if (!opt) {
+                opt = {};
+            }
+            if (!opt.silent) {
+                delete opt.silent;
+                this.raise(opt, value, 'not.real.number', 'Not real number');
+            }
+            return null;
+        }
+        return value;
+    }
+    // endregion raise
+    // region types
+    array(value, opt) {
+        if (!this.is.array(value)) {
+            this.raise(opt, value, 'invalid.array.value', 'Invalid array value');
+        }
+    }
+    boolean(value, opt) {
+        if (!this.is.boolean(value)) {
+            this.raise(opt, value, 'invalid.boolean.value', 'Invalid boolean value');
+        }
+    }
+    clazz(value, opt) {
+        if (!this.is.clazz(value)) {
+            this.raise(opt, value, 'invalid.class.value', 'Invalid class value');
+        }
+    }
+    date(value, opt) {
+        if (!(value instanceof Date)) {
+            this.raise(opt, value, 'invalid.date.value', 'Invalid date value');
+        }
+    }
+    func(value, opt) {
+        if (!this.is.func(value)) {
+            this.raise(opt, value, 'invalid.function.value', 'Invalid function value');
+        }
+    }
+    integer(value, opt) {
+        if (!this.is.integer(value)) {
+            this.raise(opt, value, 'invalid.integer.value', 'Invalid integer value');
+        }
+    }
+    key(value, opt) {
+        if (!this.is.key(value)) {
+            this.raise(opt, value, 'invalid.key.value', 'Invalid key value');
+        }
+    }
+    notEmpty(value, opt) {
+        if (this.is.empty(value)) {
+            this.raise(opt, value, 'empty.value', 'Empty value');
+        }
+    }
+    number(value, opt) {
+        if (!this.is.number(value)) {
+            this.raise(opt, value, 'invalid.number.value', 'Invalid number value');
+        }
+    }
+    object(value, opt) {
+        if (!this.is.object(value)) {
+            this.raise(opt, value, 'invalid.object.value', 'Invalid object value');
+        }
+    }
+    positiveInteger(value, opt) {
+        if (!this.is.integer(value) || (value <= 0)) {
+            this.raise(opt, value, 'invalid.positive.integer.value', 'Invalid positive integer value');
+        }
+    }
+    positiveNumber(value, opt) {
+        if (!this.is.number(value) || (value <= 0)) {
+            this.raise(opt, value, 'invalid.positive.number.value', 'Invalid positive number value');
+        }
+    }
+    primitive(value, opt) {
+        if (!this.is.primitive(value)) {
+            this.raise(opt, value, 'invalid.primitive.value', 'Invalid primitive value');
+        }
+    }
+    string(value, opt) {
+        if (!this.is.string(value)) {
+            this.raise(opt, value, 'invalid.string.value', 'Invalid string value');
+        }
+    }
+    text(value, opt) {
+        if (!this.is.text(value)) {
+            this.raise(opt, value, 'invalid.text.value', 'Invalid text value');
+        }
+        return value.trim();
+    }
+    value(value, opt) {
+        if (!this.is.text(value)) {
+            this.raise(opt, value, 'invalid.value.value', 'Invalid regular value');
+        }
+    }
+    // endregion types
+    // region secure
+    get $back() {
+        return this;
+    }
+    $init(leyyo) {
+        this.is = leyyo.is;
+        this.callback = leyyo.callback;
+    }
+    get $secure() {
+        return this;
+    }
+}
+exports.CommonAssertionImpl = CommonAssertionImpl;

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

@@ -0,0 +1,79 @@
+import { Leyyo } from "../leyyo";
+import { Arr, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
+import { TypeOpt } from "../to";
+export interface CommonAssertion extends ShiftSecure<CommonAssertionSecure> {
+    raise(opt: string, value?: any, indicator?: string, def?: string): void;
+    raise(opt: AssertionCallback, value?: any, indicator?: string, def?: string): void;
+    raise(opt: AssertionOpt, value?: any, indicator?: string, def?: string): void;
+    emptyFn(...params: Arr): void;
+    secureJson<E = unknown>(value: unknown): E;
+    realNumber(value: number, opt?: TypeOpt): number;
+    notEmpty(value: unknown, message?: string): void;
+    notEmpty(value: unknown, fn?: AssertionCallback): void;
+    notEmpty(value: unknown, opt?: AssertionOpt): void;
+    primitive(value: unknown, message?: string): void;
+    primitive(value: unknown, fn?: AssertionCallback): void;
+    primitive(value: unknown, opt?: AssertionOpt): void;
+    value(value: unknown, message?: string): void;
+    value(value: unknown, fn?: AssertionCallback): void;
+    value(value: unknown, opt?: AssertionOpt): void;
+    key(value: unknown, message?: string): void;
+    key(value: unknown, fn?: AssertionCallback): void;
+    key(value: unknown, opt?: AssertionOpt): void;
+    object(value: unknown, message?: string): void;
+    object(value: unknown, fn?: AssertionCallback): void;
+    object(value: unknown, opt?: AssertionOpt): void;
+    array(value: unknown, message?: string): void;
+    array(value: unknown, fn?: AssertionCallback): void;
+    array(value: unknown, opt?: AssertionOpt): void;
+    func(value: unknown, message?: string): void;
+    func(value: unknown, fn?: AssertionCallback): void;
+    func(value: unknown, opt?: AssertionOpt): void;
+    number(value: unknown, message?: string): void;
+    number(value: unknown, fn?: AssertionCallback): void;
+    number(value: unknown, opt?: AssertionOpt): void;
+    positiveNumber(value: unknown, message?: string): void;
+    positiveNumber(value: unknown, fn?: AssertionCallback): void;
+    positiveNumber(value: unknown, opt?: AssertionOpt): void;
+    integer(value: unknown, message?: string): void;
+    integer(value: unknown, fn?: AssertionCallback): void;
+    integer(value: unknown, opt?: AssertionOpt): void;
+    positiveInteger(value: unknown, message?: string): void;
+    positiveInteger(value: unknown, fn?: AssertionCallback): void;
+    positiveInteger(value: unknown, opt?: AssertionOpt): void;
+    string(value: unknown, message?: string): void;
+    string(value: unknown, fn?: AssertionCallback): void;
+    string(value: unknown, opt?: AssertionOpt): void;
+    text(value: unknown, message?: string): string;
+    text(value: unknown, fn?: AssertionCallback): string;
+    text(value: unknown, opt?: AssertionOpt): string;
+    clazz(value: unknown, message?: string): void;
+    clazz(value: unknown, fn?: AssertionCallback): void;
+    clazz(value: unknown, opt?: AssertionOpt): void;
+    date(value: unknown, message?: string): void;
+    date(value: unknown, fn?: AssertionCallback): void;
+    date(value: unknown, opt?: AssertionOpt): void;
+    boolean(value: unknown, message?: string): void;
+    boolean(value: unknown, fn?: AssertionCallback): void;
+    boolean(value: unknown, opt?: AssertionOpt): void;
+}
+export interface CommonAssertionSecure extends ShiftMain<CommonAssertion> {
+    $init(leyyo: Leyyo): void;
+}
+export interface AssertionOpt {
+    indicator?: AssertionReason | string;
+    param?: string;
+    where?: string;
+    value?: any;
+    expected?: OneOrMore<string>;
+    current?: string;
+    type?: string;
+    [k: string]: any;
+}
+type AssertionReason = 'invalid.type' | 'not.found' | 'duplicated' | 'empty';
+export type AssertionCallback = () => string | AssertionOpt;
+export interface AssertionBuiltResult {
+    message?: string;
+    params: AssertionOpt;
+}
+export {};

package/dist/assertion/index-types.js

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

package/dist/assertion/index.d.ts

@@ -0,0 +1,3 @@
+export * from './index-types';
+export * from './common-assertion-impl';
+export * from './assert';

package/dist/assertion/index.js

@@ -0,0 +1,19 @@
+"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("./index-types"), exports);
+__exportStar(require("./common-assertion-impl"), exports);
+__exportStar(require("./assert"), exports);

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

@@ -0,0 +1,31 @@
+import { Arr } from "../aliases";
+import { CallbackWhenDefinedLambda, CommonCallback, CommonCallbackDefined, CommonCallbackSecure } from "./index-types";
+import { Leyyo } from "../leyyo";
+export declare class CommonCallbackImpl implements CommonCallback, CommonCallbackSecure {
+    private _waitingForCallbacks;
+    private _attachedCallbacks;
+    private _waitingForProviders;
+    private _definedProviders;
+    fqnName(value: any): string;
+    /**
+     * Default constructor
+     *
+     * Responsibilities
+     * - Create repositories => ie: callbacks
+     * - Trigger clear pending operation
+     * */
+    constructor();
+    $init(leyyo: Leyyo): void;
+    /**
+     * Clear jobs in the queue which named as pending
+     *
+     * Because the expected callback may not be defined
+     * */
+    private _clearPending;
+    get $secure(): CommonCallbackSecure;
+    attachCallback(name: string, fn: Function): void;
+    queueForCallback(name: string, ...args: Arr): boolean;
+    get $back(): CommonCallback;
+    whenProviderDefined<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, consumer: Function, callback: CallbackWhenDefinedLambda<T>): void;
+    defineProvider<T extends CommonCallbackDefined = CommonCallbackDefined>(name: string, producer: Function, instance: T): void;
+}