@leyyo/common 1.0.0

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

@@ -0,0 +1,553 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonToImpl = void 0;
+const literals_1 = require("../literals");
+const error_1 = require("../error");
+// noinspection JSUnusedGlobalSymbols
+class CommonToImpl {
+    constructor() {
+        // region properties
+        this._EXPECTED_ANY = ['string', 'boolean', 'bigint', 'object', 'number', 'array'];
+        this._EXPECTED_ARRAY = ['array'];
+        this._EXPECTED_BOOL = ['boolean', 'string', 'number'];
+        this._EXPECTED_CLASS = ['string', 'function', 'object'];
+        this._EXPECTED_DATE = ['string', 'number', 'date', 'moment'];
+        this._EXPECTED_ENUM = ['string', 'number'];
+        this._EXPECTED_NUMBER = ['string', 'number', 'bigint'];
+        this._EXPECTED_STRING = ['boolean', 'string', 'number'];
+        // endregion secure
+    }
+    // endregion properties
+    // region private
+    _enumInMap(value, map) {
+        // regular, in values
+        if (Object.values(map).includes(value)) {
+            return value;
+        }
+        // ir-regular, in keys
+        if (Object.keys(map).includes(value)) {
+            return map[value];
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInMap(str, map);
+            if (v !== null) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInMap(str, map);
+            if (v !== null) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInMap(parseInt(value, 10), map);
+                }
+                catch (e) {
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    _enumInArray(value, arr) {
+        // regular, in values
+        if (arr.includes(value)) {
+            return value;
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInArray(str, arr);
+            if (v !== null) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInArray(str, arr);
+            if (v !== null) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInArray(parseInt(value, 10), arr);
+                }
+                catch (e) {
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    // noinspection JSMethodCanBeStatic
+    _enumInAlteration(value, alt) {
+        // ir-regular, in keys
+        if (Object.keys(alt).includes(value)) {
+            return alt[value];
+        }
+        if (typeof value === 'string') {
+            // regular, in lower-case
+            let str = value.toLowerCase();
+            let v = this._enumInAlteration(str, alt);
+            if (v !== null) {
+                return v;
+            }
+            // regular, in upper-case
+            str = str.toUpperCase();
+            v = this._enumInAlteration(str, alt);
+            if (v !== null) {
+                return v;
+            }
+            if (/^[0-9]+$/.test(value)) {
+                try {
+                    return this._enumInAlteration(parseInt(value, 10), alt);
+                }
+                catch (e) {
+                }
+            }
+            return null;
+        }
+        return null;
+    }
+    // endregion private
+    // region utility
+    runFn(fn, value, opt) {
+        try {
+            return fn(value());
+        }
+        catch (e) {
+            if (!opt.silent) {
+                delete opt.silent;
+                let indicator;
+                if (opt.indicator !== undefined) {
+                    indicator = opt.indicator;
+                }
+                else {
+                    indicator = 'assertion.error';
+                }
+                this.assertion.raise(opt, value.name, indicator);
+            }
+        }
+        return null;
+    }
+    runSave(fn, value, opt) {
+        try {
+            return fn(value);
+        }
+        catch (e) {
+            error_1.Exception.cast(e).raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
+        }
+        return null;
+    }
+    raiseInvalidValue(value, expected, opt, params) {
+        let indicator;
+        if (opt.indicator !== undefined) {
+            indicator = opt.indicator;
+        }
+        else {
+            indicator = 'type.invalid-value';
+        }
+        opt = Object.assign(Object.assign(Object.assign({}, opt), params), { expected, value });
+        new error_1.DeveloperException(indicator, opt)
+            .with(this)
+            .raise(!(opt === null || opt === void 0 ? void 0 : opt.silent));
+        return null;
+    }
+    // endregion utility
+    // region types
+    any(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+            case 'boolean':
+            case 'bigint':
+            case 'object':
+                return value;
+            case 'number':
+                return this.assertion.realNumber(value, opt);
+            case 'function':
+                return this.runFn(v => this.any(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_ANY, opt);
+    }
+    array(value, opt) {
+        var _a, _b;
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case "string":
+            case "boolean":
+            case "number":
+            case "bigint":
+                return this.array([value], opt);
+            case 'object':
+                if (Array.isArray(value)) {
+                    opt = opt !== null && opt !== void 0 ? opt : {};
+                    const result = [];
+                    const valueFn = (_b = (_a = opt === null || opt === void 0 ? void 0 : opt.children) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.fn;
+                    if (typeof valueFn !== "function") {
+                        result.push(...value);
+                    }
+                    else {
+                        const clonedOpt = Object.assign({}, opt);
+                        value.forEach((v, index) => {
+                            clonedOpt.param = opt.param ? `${opt.param}#${index}` : `#${index}`;
+                            try {
+                                result.push(valueFn(v, clonedOpt));
+                            }
+                            catch (e) {
+                                error_1.Exception.cast(e).raise(!opt.silent);
+                                result.push(null);
+                            }
+                        });
+                    }
+                    return result;
+                }
+                return this.array([value], opt);
+            case 'function':
+                return this.runFn(v => this.array(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_ARRAY, opt);
+    }
+    boolean(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'boolean':
+                return value;
+            case 'string':
+                value = value.trim().toLowerCase();
+                if (value === '') {
+                    return null;
+                }
+                if (literals_1.WeakTrueItems.includes(value)) {
+                    return true;
+                }
+                if (literals_1.WeakFalseItems.includes(value)) {
+                    return false;
+                }
+                return this.raiseInvalidValue(value, this._EXPECTED_BOOL, opt);
+            case 'number':
+                return value > 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.boolean(value[0], opt);
+                }
+                break;
+            case 'function':
+                return this.runFn(v => this.boolean(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_BOOL, opt);
+    }
+    clazz(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+                value = value.trim();
+                if (value === '') {
+                    return null;
+                }
+                return value;
+            case 'object':
+            case 'function':
+                return this.callback.fqnName(value);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_CLASS, opt);
+    }
+    date(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'object':
+                if (value instanceof Date) {
+                    return value;
+                }
+                else if (typeof value['toDate'] === 'function') {
+                    return this.date(this.runSave(v => v.toDate(), value, opt), opt);
+                }
+                if (Array.isArray(value)) {
+                    const arr = value;
+                    if (arr.length === 1) {
+                        return this.date(arr[0], opt);
+                    }
+                    if (arr.length > 1 && arr.length < 8) {
+                        return this.date(this.runSave(v => new Date(v[0], v[1], v[2], v[3], v[4], v[5], v[6]), value, opt), opt);
+                    }
+                }
+                else if (value.id !== undefined) {
+                    return this.date(value.id, opt);
+                }
+                break;
+            case 'string':
+                if (value.trim() === '') {
+                    return null;
+                }
+                return this.date(this.runSave(v => new Date(v), value.trim(), opt), opt);
+            case 'bigint':
+                return this.date(this.runSave(v => new Date(Number(v)), value, opt), opt);
+            case 'number':
+                return this.date(this.runSave(v => new Date(v), value, opt), opt);
+            case 'function':
+                return this.runFn(v => this.date(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_DATE, opt);
+    }
+    enumeration(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        opt = opt !== null && opt !== void 0 ? opt : {};
+        let mapType = null;
+        if (this.is.object(opt.map)) {
+            mapType = 'object';
+        }
+        else if (this.is.array(opt.map)) {
+            mapType = 'array';
+        }
+        if (!mapType) {
+            throw new error_1.DeveloperException('type.invalid-enum-items', { map: opt.map });
+        }
+        let v;
+        switch (typeof value) {
+            case 'string':
+                value = value.trim();
+                if (value === '') {
+                    return null;
+                }
+                if (mapType === 'object') {
+                    v = this._enumInMap(value, opt.map);
+                }
+                else {
+                    v = this._enumInArray(value, opt.map);
+                }
+                if (v !== null) {
+                    return v;
+                }
+                if (this.is.object(opt.alt)) {
+                    v = this._enumInAlteration(value, opt.alt);
+                    if (v !== null) {
+                        return v;
+                    }
+                }
+                return this.raiseInvalidValue(value, this._EXPECTED_ENUM, opt);
+            case 'number':
+                const num = this.assertion.realNumber(value, opt);
+                if (num === null) {
+                    return null;
+                }
+                if (mapType === 'object') {
+                    v = this._enumInMap(value, opt.map);
+                }
+                else {
+                    v = this._enumInArray(value, opt.map);
+                }
+                if (v !== null) {
+                    return v;
+                }
+                if (this.is.object(opt.alt)) {
+                    v = this._enumInAlteration(value, opt.alt);
+                    if (v !== null) {
+                        return v;
+                    }
+                }
+                return this.raiseInvalidValue(value, this._EXPECTED_ENUM, opt);
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.enumeration(value[0], opt);
+                }
+                return this.enumeration(value.id, opt);
+            case 'function':
+                return this.runFn(v => this.enumeration(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_ENUM, opt);
+    }
+    float(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+                return this.float(this.runSave(parseFloat, value.trim(), opt), opt);
+            case 'number':
+                return this.assertion.realNumber(value, opt);
+            case 'bigint':
+                return this.float(this.runSave(Number, value, opt), opt);
+            case 'boolean':
+                return value ? 1 : 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.float(value[0], opt);
+                }
+                return this.float(value.id, opt);
+            case 'function':
+                return this.runFn(v => this.float(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_NUMBER, opt);
+    }
+    func(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case "function":
+                return value;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.func(value[0], opt);
+                }
+                break;
+        }
+        return this.raiseInvalidValue(value, ['function'], opt);
+    }
+    integer(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+                return this.integer(this.runSave(parseFloat, value.trim(), opt), opt);
+            case 'number':
+                let num = this.assertion.realNumber(value, opt);
+                if (num !== null && !Number.isSafeInteger(num)) {
+                    num = Math.floor(num);
+                }
+                return num;
+            case 'bigint':
+                return this.integer(this.runSave(Number, value, opt), opt);
+            case 'boolean':
+                return value ? 1 : 0;
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.integer(value[0], opt);
+                }
+                return this.integer(value.id, opt);
+            case 'function':
+                return this.runFn(v => this.integer(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_NUMBER, opt);
+    }
+    object(value, opt) {
+        return this.dict(value, opt);
+    }
+    dict(value, opt) {
+        var _a, _b, _c, _d;
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'object':
+                if (Array.isArray(value)) {
+                    if (value.length === 1) {
+                        return this.object(value[0], opt);
+                    }
+                }
+                else {
+                    opt = opt !== null && opt !== void 0 ? opt : {};
+                    const keyOpt = Object.assign(Object.assign({}, ((_b = (_a = opt === null || opt === void 0 ? void 0 : opt.children) === null || _a === void 0 ? void 0 : _a.key) !== null && _b !== void 0 ? _b : {})), opt);
+                    if (typeof keyOpt.fn !== 'function') {
+                        keyOpt.fn = (k, o) => {
+                            if (!this.is.key(k)) {
+                                this.raiseInvalidValue(k, ['string', 'number'], o, { key: k });
+                            }
+                            return k;
+                        };
+                    }
+                    const valueOpt = Object.assign(Object.assign({}, ((_d = (_c = opt === null || opt === void 0 ? void 0 : opt.children) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : {})), opt);
+                    if (typeof valueOpt.fn !== 'function') {
+                        valueOpt.fn = (v) => {
+                            return v;
+                        };
+                    }
+                    const result = {};
+                    for (const [k, v] of Object.entries(value)) {
+                        keyOpt.param = opt.param ? `${opt.param}.${k}` : `${k}`;
+                        valueOpt.param = opt.param ? `${opt.param}.${k}` : `${k}`;
+                        try {
+                            result[keyOpt.fn(k, keyOpt)] = valueOpt.fn(v, valueOpt);
+                        }
+                        catch (e) {
+                            error_1.Exception.cast(e).raise(!opt.silent);
+                            result[k] = null;
+                        }
+                    }
+                    return result;
+                }
+                break;
+            case 'function':
+                return this.runFn(v => this.object(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, ['object'], opt);
+    }
+    string(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+                return value;
+            case 'number':
+                const num = this.assertion.realNumber(value, opt);
+                return num !== null ? num.toString(10) : null;
+            case 'bigint':
+                return value.toString();
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.string(value[0], opt);
+                }
+                return this.string(value.id, opt);
+            case 'function':
+                return this.runFn(v => this.string(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_STRING, opt);
+    }
+    text(value, opt) {
+        if (this.is.empty(value)) {
+            return null;
+        }
+        switch (typeof value) {
+            case 'string':
+                const str = value.trim();
+                return str ? str : null;
+            case 'number':
+                const num = this.assertion.realNumber(value, opt);
+                return num !== null ? num.toString(10) : null;
+            case 'bigint':
+                return value.toString();
+            case 'boolean':
+                return value ? 'true' : 'false';
+            case 'object':
+                if (Array.isArray(value) && value.length === 1) {
+                    return this.text(value[0], opt);
+                }
+                return this.text(value.id, opt);
+            case 'function':
+                return this.runFn(v => this.text(v, opt), value, opt);
+        }
+        return this.raiseInvalidValue(value, this._EXPECTED_STRING, opt);
+    }
+    // endregion types
+    // region secure
+    $init(leyyo) {
+        this.is = leyyo.is;
+        this.callback = leyyo.callback;
+        this.assertion = leyyo.assertion;
+    }
+    get $back() {
+        return this;
+    }
+    get $secure() {
+        return this;
+    }
+}
+exports.CommonToImpl = CommonToImpl;

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

@@ -0,0 +1,50 @@
+import { Dict, KeyValue, OneOrMore, ShiftMain, ShiftSecure } from "../aliases";
+import { Leyyo } from "../leyyo";
+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 {
+    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 interface TypeArrayChildOpt<V extends TypeChildOpt = TypeChildOpt> extends Dict<TypeChildOpt> {
+    value?: V;
+}
+export interface TypeArrayOpt<V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
+    children?: TypeArrayChildOpt<V>;
+}
+export interface TypeDictChildOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends Record<string, TypeChildOpt> {
+    key?: K;
+    value?: V;
+}
+export interface TypeObjectOpt<K extends TypeChildOpt = TypeChildOpt, V extends TypeChildOpt = TypeChildOpt> extends TypeOpt {
+    children?: TypeDictChildOpt<K, V>;
+}
+export interface TypeEnumOpt<E extends KeyValue = KeyValue> extends TypeOpt {
+    map: EnumerationMap<E>;
+    alt?: EnumerationAlt<E>;
+}
+export type EnumerationMap<E extends KeyValue = KeyValue> = Dict<E>;
+export type EnumerationAlt<E extends KeyValue = KeyValue> = Dict<E>;

package/dist/to/index-types.js

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

package/dist/to/index.d.ts

@@ -0,0 +1,2 @@
+export * from './index-types';
+export * from './common-to-impl';

package/dist/to/index.js

@@ -0,0 +1,18 @@
+"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-to-impl"), exports);

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@leyyo/common",
+  "version": "1.0.0",
+  "description": "Common library",
+  "keywords": [
+    "common"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leyyonet/common.git"
+  },
+  "bugs": {
+    "url": "https://github.com/leyyonet/common.git/issues",
+    "email": "mustafayelmer@gmail.com"
+  },
+  "homepage": "https://github.com/leyyonet/common.git/#readme",
+  "author": "Mustafa Yelmer <mustafayelmer@gmail.com>",
+  "main": "dist/index.js",
+  "scripts": {
+    "clear": "rimraf dist",
+    "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",
+    "test:watch": "jest --watch --config=jest.json",
+    "test:coverage": "jest --config=jest.json --coverage --coverageDirectory=coverage",
+    "~publish": "npm run build && npm publish -access=public"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.18.6",
+    "@types/jest": "^29.2.5",
+    "@types/node": "^22.13.4",
+    "@typescript-eslint/eslint-plugin": "^8.24.0",
+    "@typescript-eslint/parser": "^8.24.0",
+    "eslint": "^8.0.1",
+    "eslint-config-prettier": "^10.0.1",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-node": "^11.1.0",
+    "javascript-obfuscator": "^4.1.1",
+    "jest": "^29.3.1",
+    "prettier": "^3.5.1",
+    "rimraf": "^6.0.1",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.8.1",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+  }
+}