@samet-it/be-base-common 1.0.1

package/dist/exit/index.types.js

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

package/dist/generator/generator.d.ts

@@ -0,0 +1,2 @@
+import { GeneratorLike } from "./index.types";
+export declare const generator: GeneratorLike;

package/dist/generator/generator.js

@@ -0,0 +1,417 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const node_crypto_1 = require("node:crypto");
+const NUMERIC = '0123456789';
+const UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+const LOWER = 'abcdefghijklmnopqrstuvwxyz';
+const ALPHABET = NUMERIC + UPPER + LOWER;
+const SECONDS = 1000;
+const MINUTES = SECONDS * 60;
+const HOURS = MINUTES * 60;
+const DAYS = HOURS * 24;
+const MONTHS = DAYS * 12;
+const YEARS = DAYS * 365;
+const LOREM = [
+    'lorem', 'ipsum', 'dolor', 'sit', 'amet', 'consectetur',
+    'adipiscing', 'elit', 'curabitur', 'vel', 'hendrerit', 'libero',
+    'eleifend', 'blandit', 'nunc', 'ornare', 'odio', 'ut',
+    'orci', 'gravida', 'imperdiet', 'nullam', 'purus', 'lacinia',
+    'a', 'pretium', 'quis', 'congue', 'praesent', 'sagittis',
+    'laoreet', 'auctor', 'mauris', 'non', 'velit', 'eros',
+    'dictum', 'proin', 'accumsan', 'sapien', 'nec', 'massa',
+    'volutpat', 'venenatis', 'sed', 'eu', 'molestie', 'lacus',
+    'quisque', 'porttitor', 'ligula', 'dui', 'mollis', 'tempus',
+    'at', 'magna', 'vestibulum', 'turpis', 'ac', 'diam',
+    'tincidunt', 'id', 'condimentum', 'enim', 'sodales', 'in',
+    'hac', 'habitasse', 'platea', 'dictumst', 'aenean', 'neque',
+    'fusce', 'augue', 'leo', 'eget', 'semper', 'mattis',
+    'tortor', 'scelerisque', 'nulla', 'interdum', 'tellus', 'malesuada',
+    'rhoncus', 'porta', 'sem', 'aliquet', 'et', 'nam',
+    'suspendisse', 'potenti', 'vivamus', 'luctus', 'fringilla', 'erat',
+    'donec', 'justo', 'vehicula', 'ultricies', 'varius', 'ante',
+    'primis', 'faucibus', 'ultrices', 'posuere', 'cubilia', 'curae',
+    'etiam', 'cursus', 'aliquam', 'quam', 'dapibus', 'nisl',
+    'feugiat', 'egestas', 'class', 'aptent', 'taciti', 'sociosqu',
+    'ad', 'litora', 'torquent', 'per', 'conubia', 'nostra',
+    'inceptos', 'himenaeos', 'phasellus', 'nibh', 'pulvinar', 'vitae',
+    'urna', 'iaculis', 'lobortis', 'nisi', 'viverra', 'arcu',
+    'morbi', 'pellentesque', 'metus', 'commodo', 'ut', 'facilisis',
+    'felis', 'tristique', 'ullamcorper', 'placerat', 'aenean', 'convallis',
+    'sollicitudin', 'integer', 'rutrum', 'duis', 'est', 'etiam',
+    'bibendum', 'donec', 'pharetra', 'vulputate', 'maecenas', 'mi',
+    'fermentum', 'consequat', 'suscipit', 'aliquam', 'habitant', 'senectus',
+    'netus', 'fames', 'quisque', 'euismod', 'curabitur', 'lectus',
+    'elementum', 'tempor', 'risus', 'cras'
+];
+class Generator {
+    constructor() {
+        this._start = new Date().getTime();
+    }
+    /**
+     * Checks number value in a range
+     *
+     * @param {number} value - value should be verified
+     * @param {number} min - min limit
+     * @param {number} max - max limit
+     * @param {number} def - default limit
+     * */
+    _range(value, min, max, def) {
+        if (typeof value !== "number") {
+            return def !== null && def !== void 0 ? def : min;
+        }
+        if (value < min) {
+            return min;
+        }
+        if (value > max) {
+            return max;
+        }
+        return value;
+    }
+    /**
+     * Shuffles an array
+     *
+     * @param {Array} list - array
+     * */
+    _shuffle(list) {
+        const items = [...list];
+        for (let i = items.length - 1; i >= 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [items[i], items[j]] = [items[j], items[i]];
+        }
+        return items;
+    }
+    /**
+     * Handles min max
+     *
+     * @param {number} p1 - min or max
+     * @param {number} p2 - max
+     * @returns {Array} min max tuple
+     * */
+    _minMax(p1, p2) {
+        let min;
+        let max;
+        if (typeof p2 === 'number') {
+            max = p2;
+            if (typeof p1 === 'number') {
+                min = p1;
+            }
+        }
+        else if (typeof p1 === 'number') {
+            max = p1;
+        }
+        if (min === undefined) {
+            if (max === undefined) {
+                min = 0;
+                max = 1000;
+            }
+            else {
+                min = max - 1000;
+            }
+        }
+        else if (max === undefined) {
+            max = min + 1000;
+        }
+        if (min > max) {
+            const swap = min;
+            min = max;
+            max = swap;
+        }
+        if (min === max) {
+            max = min + 1;
+        }
+        return [min, max];
+    }
+    /**
+     * Checks size
+     *
+     * @param {(number|boolean)} size - size of array, if it's true, use randomize
+     * */
+    _checkSize(size) {
+        if (size === true) {
+            return 1 + Math.floor(Math.random() * 5);
+        }
+        return Math.floor(this._range(size, 1, 5, 3));
+    }
+    /**
+     * Helper to produce an array of enum values.
+     * @param enumeration Enumeration object.
+     */
+    _enumToArray(enumeration) {
+        return Object.keys(enumeration)
+            .filter(key => isNaN(Number(key)))
+            .map(key => enumeration[key])
+            .filter(val => typeof val === "number" || typeof val === "string");
+    }
+    /** {@inheritDoc} */
+    buildConstructor(instance, given) {
+        if (given && typeof given === 'object' && !Array.isArray(given)) {
+            for (const [k, v] of Object.entries(given)) {
+                instance[k] = v;
+            }
+        }
+    }
+    /** {@inheritDoc} */
+    forLength(size, fn) {
+        size = this._checkSize(size);
+        const items = [];
+        for (let i = 0; i < size; i++) {
+            items.push(fn());
+        }
+        return items;
+    }
+    /** {@inheritDoc} */
+    word(p1, p2) {
+        let length;
+        let alphabet;
+        if (typeof p1 === 'number') {
+            length = p1;
+            if (typeof p2 === 'string') {
+                alphabet = p2.trim();
+            }
+        }
+        else if (typeof p1 === 'string') {
+            alphabet = p1.trim();
+        }
+        if (!alphabet) {
+            alphabet = ALPHABET;
+        }
+        length = this._range(length, 1, 100, 5);
+        let result = '';
+        const charactersLength = alphabet.length;
+        let counter = 0;
+        while (counter < length) {
+            result += alphabet.charAt(Math.floor(Math.random() * charactersLength));
+            counter += 1;
+        }
+        return result;
+    }
+    /** {@inheritDoc} */
+    wordArray(size, p1, p2) {
+        return this.forLength(size, () => this.word(p1, p2));
+    }
+    /** {@inheritDoc} */
+    numeric(length) {
+        return this.word(length, NUMERIC);
+    }
+    /** {@inheritDoc} */
+    numericArray(size, length) {
+        return this.forLength(size, () => this.numeric(length));
+    }
+    /** {@inheritDoc} */
+    firstUpper(length) {
+        return this.word(1, UPPER) + this.word(length, LOWER);
+    }
+    /** {@inheritDoc} */
+    firstUpperArray(size, length) {
+        return this.forLength(size, () => this.firstUpper(length));
+    }
+    /** {@inheritDoc} */
+    upper(length) {
+        return this.word(length, UPPER);
+    }
+    /** {@inheritDoc} */
+    upperArray(size, length) {
+        return this.forLength(size, () => this.upper(length));
+    }
+    /** {@inheritDoc} */
+    lower(length) {
+        return this.word(length, LOWER);
+    }
+    /** {@inheritDoc} */
+    lowerArray(size, length) {
+        return this.forLength(size, () => this.lower(length));
+    }
+    /** {@inheritDoc} */
+    loremIpsum(count) {
+        const items = this._shuffle(LOREM);
+        count = this._range(count, 1, items.length);
+        return items.slice(0, count).join(' ');
+    }
+    /** {@inheritDoc} */
+    loremIpsumArray(size, count) {
+        return this.forLength(size, () => this.loremIpsum(count));
+    }
+    /** {@inheritDoc} */
+    integer(p1, p2) {
+        let [min, max] = this._minMax(p1, p2);
+        min = Math.ceil(min);
+        max = Math.ceil(max);
+        return min + Math.floor(Math.random() * (max - min + 1));
+    }
+    /** {@inheritDoc} */
+    integerArray(size, p1, p2) {
+        return this.forLength(size, () => this.integer(p1, p2));
+    }
+    /** {@inheritDoc} */
+    double(p1, p2) {
+        let [min, max] = this._minMax(p1, p2);
+        return min + (Math.random() * (max - min));
+    }
+    /** {@inheritDoc} */
+    doubleArray(size, p1, p2) {
+        return this.forLength(size, () => this.double(p1, p2));
+    }
+    /** {@inheritDoc} */
+    uuid() {
+        return (0, node_crypto_1.randomUUID)();
+    }
+    /** {@inheritDoc} */
+    uuidArray(size) {
+        return this.forLength(size, () => this.uuid());
+    }
+    /** {@inheritDoc} */
+    boolean() {
+        return Math.random() >= 0.5;
+    }
+    /** {@inheritDoc} */
+    booleanArray(size) {
+        return this.forLength(size, () => this.boolean());
+    }
+    /** {@inheritDoc} */
+    timestamp(type, value, pastFuture) {
+        let diff;
+        value = this._range(value, 1, 1000, 10);
+        switch (type) {
+            case "year":
+            case "y":
+                diff = YEARS * value;
+                break;
+            case "month":
+            case "m":
+                diff = MONTHS * value;
+                break;
+            case "day":
+            case "d":
+                diff = DAYS * value;
+                break;
+            case "hour":
+            case "h":
+                diff = HOURS * value;
+                break;
+            case "minute":
+            case "i":
+                diff = MINUTES * value;
+                break;
+            case "second":
+            case "s":
+                diff = SECONDS * value;
+                break;
+            default:
+                diff = DAYS * value;
+                break;
+        }
+        switch (pastFuture) {
+            case "past":
+                diff *= -1;
+                break;
+            case "future":
+                break;
+            default: // both
+                if (this.boolean()) {
+                    diff *= -1;
+                }
+                break;
+        }
+        return this._start + Math.random() * diff;
+    }
+    /** {@inheritDoc} */
+    timestampArray(size, type, value, pastFuture) {
+        return this.forLength(size, () => this.timestamp(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    datetime(type, value, pastFuture) {
+        return new Date(this.timestamp(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    datetimeArray(size, type, value, pastFuture) {
+        return this.forLength(size, () => this.datetime(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    isoDate(type, value, pastFuture) {
+        return new Date(this.timestamp(type, value, pastFuture)).toISOString();
+    }
+    /** {@inheritDoc} */
+    isoDateArray(size, type, value, pastFuture) {
+        return this.forLength(size, () => this.isoDate(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    date(type, value, pastFuture) {
+        return this.isoDate(type, value, pastFuture).substring(0, 10);
+    }
+    /** {@inheritDoc} */
+    dateArray(size, type, value, pastFuture) {
+        return this.forLength(size, () => this.date(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    time(type, value, pastFuture) {
+        return this.isoDate(type, value, pastFuture).substring(11, 8);
+    }
+    /** {@inheritDoc} */
+    timeArray(size, type, value, pastFuture) {
+        return this.forLength(size, () => this.time(type, value, pastFuture));
+    }
+    /** {@inheritDoc} */
+    enum(keys) {
+        if (keys && typeof keys === 'object' && !Array.isArray(keys)) {
+            const arr = this._enumToArray(keys);
+            return arr[Math.floor(Math.random() * arr.length)];
+        }
+        else if (Array.isArray(keys)) {
+            return keys[Math.floor(Math.random() * keys.length)];
+        }
+        return null;
+    }
+    /** {@inheritDoc} */
+    enumArray(size, keys) {
+        let items;
+        if (keys && typeof keys === 'object' && !Array.isArray(keys)) {
+            items = this._enumToArray(keys);
+        }
+        else if (Array.isArray(keys)) {
+            items = [...keys];
+        }
+        items = this._shuffle(items);
+        if (size > items.length) {
+            size = items.length;
+        }
+        return items.slice(0, size);
+    }
+    /** {@inheritDoc} */
+    urn(...parts) {
+        let size = 1;
+        if (parts.length > 0) {
+            if (typeof parts[0] === "number") {
+                size = parts.shift();
+            }
+        }
+        const domains = parts.map(part => {
+            switch (typeof part) {
+                case "string":
+                    const str = part.trim();
+                    return str ? str : undefined;
+                case "number":
+                case "bigint":
+                    return part.toString(10);
+                case "boolean":
+                    return part ? 'true' : 'false';
+                default:
+                    return undefined;
+            }
+        }).filter(part => !!part);
+        if (domains.length < 1) {
+            domains.push(this.word(3), this.word(5));
+        }
+        if (!Number.isInteger(size)) {
+            size = 1;
+        }
+        const keys = [];
+        for (let i = 0; i < size; i++) {
+            keys.push(this.integer());
+        }
+        domains.push(keys.join('|'));
+        return domains.join(':');
+    }
+}
+// noinspection JSUnusedGlobalSymbols
+exports.generator = new Generator();

package/dist/generator/index.d.ts

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

package/dist/generator/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("./generator"), exports);
+__exportStar(require("./index.types"), exports);