@atlantjs/arch 15.6.7 → 15.7.0

package/src/@tool-box/utils/http-provider/http-provider.js

@@ -1,85 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpProvider = void 0;
-const axios_1 = __importDefault(require("axios"));
-const return_type_1 = require("#/@tool-box/utils/ducts/return-type");
-const http_provider_failure_response_1 = require("#/@tool-box/utils/http-provider/http-provider-failure-response");
-const http_provider_success_response_1 = require("#/@tool-box/utils/http-provider/http-provider-success-response");
-const http_status_codes_point_1 = require("#/objects/@common/points/http-status-codes.point");
-function replaceUrlParams(url, params) {
-    return url.replace(/:([a-zA-Z0-9_]+)/g, (_, key) => {
-        const value = params[key];
-        if (value === undefined) {
-            throw new Error(`Parâmetro "${key}" não encontrado em params`);
-        }
-        return encodeURIComponent(String(value));
-    });
-}
-class HttpProvider {
-    constructor(baseUrl) {
-        this.baseUrl = baseUrl;
-        this.axios = axios_1.default.create({
-            baseURL: baseUrl,
-        });
-    }
-    setDefaultHeader(key, value) {
-        this.axios.defaults.headers.common[key] = value;
-    }
-    removeDefaultHeader(key) {
-        delete this.axios.defaults.headers.common[key];
-    }
-    setBearerToken(token) {
-        this.setDefaultHeader("Authorization", `Bearer ${token}`);
-    }
-    async request(request) {
-        let resolvedUrl = request.url;
-        try {
-            if (request.params) {
-                resolvedUrl = replaceUrlParams(resolvedUrl, request.params);
-            }
-            const response = await this.axios.request({
-                url: resolvedUrl,
-                method: request.method,
-                params: request.queryParams,
-                data: request.payload,
-                headers: request.headers,
-                responseType: request.responseType,
-                validateStatus: () => true,
-            });
-            if (!this.isSuccessStatus(response.status)) {
-                return (0, return_type_1.Failure)(this.buildFailureFromResponse(response, resolvedUrl));
-            }
-            return (0, return_type_1.Success)(new http_provider_success_response_1.HttpProviderSuccessResponse(response.status, response.data));
-        }
-        catch (error) {
-            if (axios_1.default.isAxiosError(error) && error.response) {
-                return (0, return_type_1.Failure)(this.buildFailureFromResponse(error.response, resolvedUrl));
-            }
-            return (0, return_type_1.Failure)(new http_provider_failure_response_1.HttpProviderFailureResponse("The request could not be completed. The server is currently unavailable.", http_status_codes_point_1.HttpStatusCodes.SERVICE_UNAVAILABLE, resolvedUrl));
-        }
-    }
-    isSuccessStatus(status) {
-        return status >= 200 && status < 300;
-    }
-    buildFailureFromResponse(response, url) {
-        return new http_provider_failure_response_1.HttpProviderFailureResponse(this.extractErrorMessage(response.data, response.statusText), response.status, url);
-    }
-    extractErrorMessage(data, fallback) {
-        if (typeof data === "string" && data.trim().length > 0) {
-            return data;
-        }
-        if (data && typeof data === "object") {
-            const maybeMessage = data.message;
-            if (typeof maybeMessage === "string" && maybeMessage.trim().length > 0) {
-                return maybeMessage;
-            }
-        }
-        return fallback?.trim()
-            ? fallback
-            : "The request failed. Please try again later.";
-    }
-}
-exports.HttpProvider = HttpProvider;

package/src/@tool-box/utils/logger/index.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.c = void 0;
-exports.c = {
-    log: (prefix, value) => {
-        console.log(prefix, JSON.stringify(value, (key, val) => {
-            if (val && typeof val === "object" && val.constructor !== Object) {
-                const symbolKeys = Object.getOwnPropertySymbols(val);
-                const symbolProps = symbolKeys.reduce((acc, sym) => {
-                    acc[sym.toString()] = val[sym];
-                    return acc;
-                }, {});
-                return { ...val, ...symbolProps };
-            }
-            return val;
-        }, 2));
-    },
-    warn: (prefix, value) => {
-        console.warn(prefix, JSON.stringify(value, (key, val) => {
-            if (val && typeof val === "object" && val.constructor !== Object) {
-                const symbolKeys = Object.getOwnPropertySymbols(val);
-                const symbolProps = symbolKeys.reduce((acc, sym) => {
-                    acc[sym.toString()] = val[sym];
-                    return acc;
-                }, {});
-                return { ...val, ...symbolProps };
-            }
-            return val;
-        }, 2));
-    },
-};

package/src/@tool-box/utils/map/map.abstract.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapAbstract = void 0;
-class MapAbstract {
-    /**
-     * Mantido por compatibilidade.
-     * Retorna o valor mapeado para a chave ou lança erro.
-     */
-    toMap(key) {
-        return this.getOrThrow(key);
-    }
-    /**
-     * Retorna o valor mapeado para a chave ou lança erro.
-     */
-    get(key) {
-        return this.getOrThrow(key);
-    }
-    /**
-     * Retorna true se a chave existir no map.
-     */
-    has(key) {
-        return this.map.has(key);
-    }
-    /**
-     * Retorna o valor ou undefined.
-     */
-    getOrUndefined(key) {
-        return this.map.get(key);
-    }
-    /**
-     * Retorna a quantidade de itens.
-     */
-    size() {
-        return this.map.size;
-    }
-    /**
-     * Retorna true se o map estiver vazio.
-     */
-    isEmpty() {
-        return this.map.size === 0;
-    }
-    /**
-     * Retorna todas as chaves.
-     */
-    keys() {
-        return Array.from(this.map.keys());
-    }
-    /**
-     * Retorna todos os valores.
-     */
-    values() {
-        return Array.from(this.map.values());
-    }
-    /**
-     * Retorna todas as entradas.
-     */
-    entries() {
-        return Array.from(this.map.entries());
-    }
-    getOrDefault(key, defaultValue) {
-        // bug fix: usar has() evita confundir chave existente com valor undefined
-        if (!this.map.has(key)) {
-            return defaultValue;
-        }
-        return this.map.get(key);
-    }
-    getOrThrow(key, errorMessage = "Key not mapped") {
-        // bug fix: validar existência da chave com has(), não pelo valor retornado
-        if (!this.map.has(key)) {
-            throw new Error(errorMessage);
-        }
-        return this.map.get(key);
-    }
-    set(key, value) {
-        this.map.set(key, value);
-    }
-    delete(key) {
-        return this.map.delete(key);
-    }
-    clear() {
-        this.map.clear();
-    }
-}
-exports.MapAbstract = MapAbstract;

package/src/@tool-box/utils/random/random.js

@@ -1,260 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Random = void 0;
-class Random {
-    // ==================== Números ====================
-    /**
-     * Gera um número inteiro aleatório dentro de um intervalo (inclusivo).
-     * @param min - Valor mínimo do intervalo
-     * @param max - Valor máximo do intervalo
-     * @returns Número inteiro aleatório entre min e max
-     * @example
-     * Random.number(1, 10) // pode retornar qualquer inteiro entre 1 e 10
-     */
-    static number(min, max) {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-    /**
-     * Gera um número decimal (float) aleatório dentro de um intervalo.
-     * @param min - Valor mínimo do intervalo
-     * @param max - Valor máximo do intervalo
-     * @param precision - Número de casas decimais (padrão: 2)
-     * @returns Número decimal aleatório entre min e max
-     * @example
-     * Random.float(1, 10) // pode retornar algo como 4.73
-     * Random.float(1, 10, 4) // pode retornar algo como 4.7312
-     */
-    static float(min, max, precision = 2) {
-        const value = Math.random() * (max - min) + min;
-        return Number(value.toFixed(precision));
-    }
-    /**
-     * Gera um número inteiro positivo aleatório até um valor máximo.
-     * @param max - Valor máximo do intervalo (padrão: 100)
-     * @returns Número inteiro positivo aleatório entre 1 e max
-     * @example
-     * Random.positiveNumber() // pode retornar qualquer inteiro entre 1 e 100
-     * Random.positiveNumber(50) // pode retornar qualquer inteiro entre 1 e 50
-     */
-    static positiveNumber(max = 100) {
-        return Random.number(1, max);
-    }
-    /**
-     * Gera um número inteiro negativo aleatório até um valor mínimo.
-     * @param min - Valor mínimo do intervalo (padrão: -100)
-     * @returns Número inteiro negativo aleatório entre min e -1
-     * @example
-     * Random.negativeNumber() // pode retornar qualquer inteiro entre -100 e -1
-     * Random.negativeNumber(-50) // pode retornar qualquer inteiro entre -50 e -1
-     */
-    static negativeNumber(min = -100) {
-        return Random.number(min, -1);
-    }
-    // ==================== Enums ====================
-    /**
-     * Retorna um valor aleatório de um enum.
-     * @template T - Tipo do enum
-     * @param anEnum - Enum do qual será selecionado o valor aleatório
-     * @returns Um valor aleatório do enum
-     * @example
-     * enum Color { Red, Green, Blue }
-     * Random.enum(Color) // pode retornar Color.Red, Color.Green ou Color.Blue
-     */
-    static enum(anEnum) {
-        const keys = Object.keys(anEnum).filter((x) => Number.isNaN(Number(x)));
-        const randomKeyIndex = Math.floor(Math.random() * keys.length);
-        const randomKey = keys[randomKeyIndex];
-        return anEnum[randomKey];
-    }
-    /**
-     * Retorna um valor aleatório de um enum, excluindo valores específicos.
-     * @template T - Tipo do enum
-     * @param anEnum - Enum do qual será selecionado o valor aleatório
-     * @param excepts - Array de valores do enum que devem ser excluídos da seleção
-     * @returns Um valor aleatório do enum que não está nos excepts
-     * @throws {Error} Se não houver valores válidos após aplicar as exclusões
-     * @example
-     * enum Color { Red, Green, Blue }
-     * Random.enumExcluding(Color, [Color.Red]) // retorna Green ou Blue
-     */
-    static enumExcluding(anEnum, excepts) {
-        const exceptKeys = excepts.map((value) => Object.keys(anEnum).find((key) => anEnum[key] === value));
-        const validKeys = Object.keys(anEnum).filter((key) => Number.isNaN(Number(key)) && !exceptKeys.includes(key));
-        if (validKeys.length === 0) {
-            throw new Error("No valid enum keys available after excluding 'excepts'.");
-        }
-        const randomKeyIndex = Math.floor(Math.random() * validKeys.length);
-        const randomKey = validKeys[randomKeyIndex];
-        return anEnum[randomKey];
-    }
-    // ==================== Strings ====================
-    /**
-     * Gera uma string aleatória de caracteres alfanuméricos.
-     * @param length - Comprimento da string a ser gerada (padrão: 8)
-     * @returns String aleatória com o comprimento especificado
-     * @example
-     * Random.string() // pode retornar "aB3xKp9z"
-     * Random.string(4) // pode retornar "kR2m"
-     */
-    static string(length = 8) {
-        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join("");
-    }
-    /**
-     * Gera uma string aleatória contendo apenas letras (sem números).
-     * @param length - Comprimento da string a ser gerada (padrão: 8)
-     * @returns String aleatória com apenas letras
-     * @example
-     * Random.letters() // pode retornar "AbCdEfGh"
-     * Random.letters(4) // pode retornar "kRmZ"
-     */
-    static letters(length = 8) {
-        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-        return Array.from({ length }, () => chars.charAt(Math.floor(Math.random() * chars.length))).join("");
-    }
-    /**
-     * Gera um UUID v4 aleatório no formato padrão.
-     * @returns UUID no formato xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
-     * @example
-     * Random.uuid() // pode retornar "550e8400-e29b-41d4-a716-446655440000"
-     */
-    static uuid() {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
-            const random = (Math.random() * 16) | 0;
-            const value = char === "x" ? random : (random & 0x3) | 0x8;
-            return value.toString(16);
-        });
-    }
-    // ==================== Booleanos ====================
-    /**
-     * Gera um valor booleano aleatório (true ou false).
-     * @returns true ou false aleatoriamente
-     * @example
-     * Random.boolean() // pode retornar true ou false
-     */
-    static boolean() {
-        return Math.random() < 0.5;
-    }
-    /**
-     * Gera um valor booleano aleatório com uma probabilidade específica de ser true.
-     * @param probability - Probabilidade de retornar true (0 a 1, padrão: 0.5)
-     * @returns true com a probabilidade fornecida, false caso contrário
-     * @example
-     * Random.booleanWithProbability(0.8) // 80% de chance de retornar true
-     * Random.booleanWithProbability(0.2) // 20% de chance de retornar true
-     */
-    static booleanWithProbability(probability = 0.5) {
-        return Math.random() < probability;
-    }
-    // ==================== Arrays ====================
-    /**
-     * Retorna um elemento aleatório de um array.
-     * @template T - Tipo dos elementos do array
-     * @param array - Array do qual será selecionado um elemento
-     * @returns Um elemento aleatório do array
-     * @throws {Error} Se o array estiver vazio
-     * @example
-     * Random.arrayElement([1, 2, 3, 4]) // pode retornar 1, 2, 3 ou 4
-     * Random.arrayElement(["a", "b", "c"]) // pode retornar "a", "b" ou "c"
-     */
-    static arrayElement(array) {
-        if (array.length === 0) {
-            throw new Error("Cannot get a random element from an empty array.");
-        }
-        return array[Math.floor(Math.random() * array.length)];
-    }
-    /**
-     * Retorna um elemento aleatório de um array, excluindo valores específicos.
-     * @template T - Tipo dos elementos do array
-     * @param array - Array do qual será selecionado um elemento
-     * @param excepts - Array de valores que devem ser excluídos da seleção
-     * @returns Um elemento aleatório do array que não está nos excepts
-     * @throws {Error} Se não houver elementos válidos após aplicar as exclusões
-     * @example
-     * Random.arrayElementExcluding([1, 2, 3, 4], [2, 4]) // pode retornar 1 ou 3
-     */
-    static arrayElementExcluding(array, excepts) {
-        const validElements = array.filter((item) => !excepts.includes(item));
-        if (validElements.length === 0) {
-            throw new Error("No valid elements available after excluding 'excepts'.");
-        }
-        return Random.arrayElement(validElements);
-    }
-    /**
-     * Retorna múltiplos elementos aleatórios únicos de um array.
-     * @template T - Tipo dos elementos do array
-     * @param array - Array do qual serão selecionados os elementos
-     * @param count - Quantidade de elementos a retornar
-     * @returns Array com elementos aleatórios únicos
-     * @throws {Error} Se count for maior que o tamanho do array
-     * @example
-     * Random.arrayElements([1, 2, 3, 4, 5], 3) // pode retornar [3, 1, 5]
-     */
-    static arrayElements(array, count) {
-        if (count > array.length) {
-            throw new Error(`Cannot pick ${count} elements from an array of ${array.length}.`);
-        }
-        const shuffled = [...array].sort(() => Math.random() - 0.5);
-        return shuffled.slice(0, count);
-    }
-    /**
-     * Retorna uma cópia do array com a ordem dos elementos embaralhada.
-     * @template T - Tipo dos elementos do array
-     * @param array - Array a ser embaralhado
-     * @returns Novo array com os mesmos elementos em ordem aleatória
-     * @example
-     * Random.shuffle([1, 2, 3, 4]) // pode retornar [3, 1, 4, 2]
-     */
-    static shuffle(array) {
-        const shuffled = [...array];
-        for (let i = shuffled.length - 1; i > 0; i--) {
-            const j = Math.floor(Math.random() * (i + 1));
-            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-        }
-        return shuffled;
-    }
-    // ==================== Datas ====================
-    /**
-     * Gera uma data aleatória dentro de um intervalo.
-     * @param start - Data inicial do intervalo
-     * @param end - Data final do intervalo
-     * @returns Data aleatória entre start e end
-     * @example
-     * Random.date(new Date("2020-01-01"), new Date("2024-12-31"))
-     * // pode retornar qualquer data entre 2020 e 2024
-     */
-    static date(start, end) {
-        const startTime = start.getTime();
-        const endTime = end.getTime();
-        return new Date(startTime + Math.random() * (endTime - startTime));
-    }
-    /**
-     * Gera uma data aleatória no passado a partir da data atual.
-     * @param daysAgo - Quantidade máxima de dias no passado (padrão: 365)
-     * @returns Data aleatória entre daysAgo dias atrás e hoje
-     * @example
-     * Random.pastDate() // data aleatória no último ano
-     * Random.pastDate(30) // data aleatória nos últimos 30 dias
-     */
-    static pastDate(daysAgo = 365) {
-        const now = new Date();
-        const past = new Date();
-        past.setDate(past.getDate() - daysAgo);
-        return Random.date(past, now);
-    }
-    /**
-     * Gera uma data aleatória no futuro a partir da data atual.
-     * @param daysAhead - Quantidade máxima de dias no futuro (padrão: 365)
-     * @returns Data aleatória entre hoje e daysAhead dias à frente
-     * @example
-     * Random.futureDate() // data aleatória no próximo ano
-     * Random.futureDate(30) // data aleatória nos próximos 30 dias
-     */
-    static futureDate(daysAhead = 365) {
-        const now = new Date();
-        const future = new Date();
-        future.setDate(future.getDate() + daysAhead);
-        return Random.date(now, future);
-    }
-}
-exports.Random = Random;

package/src/@tool-box/utils/type-guard/guardian-exception.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GuardianException = void 0;
-class GuardianException extends Error {
-}
-exports.GuardianException = GuardianException;