@atlantjs/arch 15.7.6 → 15.7.8

package/src/@tool-box/utils/datatypes/boolean-utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Verifica se o valor booleano é verdadeiro (true).
+ * @returns true se o valor é true, false caso contrário
+ * @example
+ * (true).truthy() // true
+ * (false).truthy() // false
+ */
+Boolean.prototype.truthy = function () {
+    return this.valueOf() === true;
+};
+/**
+ * Verifica se o valor booleano é falso (false ou undefined).
+ * @returns true se o valor é false ou undefined, false caso contrário
+ * @example
+ * (false).falsy() // true
+ * (true).falsy() // false
+ */
+Boolean.prototype.falsy = function () {
+    return this.valueOf() === false || this.valueOf() === undefined;
+};
+/**
+ * Retorna o valor booleano negado (inversão lógica).
+ * @returns true se o valor é false, false se o valor é true
+ * @example
+ * (true).not() // false
+ * (false).not() // true
+ */
+Boolean.prototype.not = function () {
+    return !this.valueOf();
+};
+/**
+ * Realiza a operação lógica AND (E) entre este valor e outro.
+ * Retorna true somente se ambos os valores forem true.
+ * @param value - Segundo operando booleano
+ * @returns true se ambos são true, false caso contrário
+ * @example
+ * (true).and(true) // true
+ * (true).and(false) // false
+ * (false).and(true) // false
+ */
+Boolean.prototype.and = function (value) {
+    return this.valueOf() === true && value === true;
+};
+/**
+ * Realiza a operação lógica OR (OU) entre este valor e outro.
+ * Retorna true se pelo menos um dos valores for true.
+ * @param value - Segundo operando booleano
+ * @returns true se pelo menos um é true, false caso contrário
+ * @example
+ * (true).or(false) // true
+ * (false).or(false) // false
+ * (false).or(true) // true
+ */
+Boolean.prototype.or = function (value) {
+    return this.valueOf() === true || value === true;
+};
+/**
+ * Verifica se este valor booleano é igual a outro.
+ * @param value - Valor booleano para comparação
+ * @returns true se os valores são iguais, false caso contrário
+ * @example
+ * (true).equal(true) // true
+ * (true).equal(false) // false
+ */
+Boolean.prototype.equal = function (value) {
+    return this.valueOf() === value;
+};
+/**
+ * Verifica se este valor booleano é diferente de outro.
+ * @param value - Valor booleano para comparação
+ * @returns true se os valores são diferentes, false caso contrário
+ * @example
+ * (true).different(false) // true
+ * (true).different(true) // false
+ */
+Boolean.prototype.different = function (value) {
+    return this.valueOf() !== value;
+};
+/**
+ * Realiza a operação lógica XOR (OU exclusivo) entre este valor e outro.
+ * Retorna true somente se exatamente um dos valores for true.
+ * @param value - Segundo operando booleano
+ * @returns true se exatamente um é true, false caso contrário
+ * @example
+ * (true).xor(false) // true
+ * (true).xor(true) // false
+ * (false).xor(false) // false
+ */
+Boolean.prototype.xor = function (value) {
+    return this.valueOf() !== value;
+};
+/**
+ * Realiza a operação lógica NAND (NÃO-E) entre este valor e outro.
+ * Retorna false somente se ambos os valores forem true.
+ * @param value - Segundo operando booleano
+ * @returns false se ambos são true, true caso contrário
+ * @example
+ * (true).nand(true) // false
+ * (true).nand(false) // true
+ * (false).nand(false) // true
+ */
+Boolean.prototype.nand = function (value) {
+    return !(this.valueOf() === true && value === true);
+};
+/**
+ * Realiza a operação lógica NOR (NÃO-OU) entre este valor e outro.
+ * Retorna true somente se ambos os valores forem false.
+ * @param value - Segundo operando booleano
+ * @returns true se ambos são false, false caso contrário
+ * @example
+ * (false).nor(false) // true
+ * (true).nor(false) // false
+ * (true).nor(true) // false
+ */
+Boolean.prototype.nor = function (value) {
+    return !(this.valueOf() === true || value === true);
+};
+/**
+ * Realiza a operação lógica de implicação (→) entre este valor e outro.
+ * Retorna false somente se este valor é true e o outro é false.
+ * @param value - Consequente da implicação
+ * @returns false se this é true e value é false, true caso contrário
+ * @example
+ * (true).implies(true) // true
+ * (true).implies(false) // false
+ * (false).implies(true) // true
+ * (false).implies(false) // true
+ */
+Boolean.prototype.implies = function (value) {
+    return !this.valueOf() || value;
+};
+/**
+ * Converte o valor booleano para número.
+ * true é convertido para 1, false para 0.
+ * @returns 1 se o valor é true, 0 se o valor é false
+ * @example
+ * (true).toNumber() // 1
+ * (false).toNumber() // 0
+ */
+Boolean.prototype.toNumber = function () {
+    return this.valueOf() ? 1 : 0;
+};
+/**
+ * Retorna o valor booleano invertido sem alterar o original.
+ * Equivalente a `.not()`, porém semânticamente indica alternância de estado.
+ * @returns true se o valor é false, false se o valor é true
+ * @example
+ * (true).toggle() // false
+ * (false).toggle() // true
+ */
+Boolean.prototype.toggle = function () {
+    return !this.valueOf();
+};

package/src/@tool-box/utils/datatypes/generic-types.d.ts

@@ -5,4 +5,3 @@ export interface Sketch<T> {
     prototype: T;
 }
 export {};
-//# sourceMappingURL=generic-types.d.ts.map

package/src/@tool-box/utils/datatypes/generic-types.js

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

package/src/@tool-box/utils/datatypes/plainify.d.ts

@@ -4,4 +4,3 @@ export type Plainify<T> = T extends Primitive ? T : T extends Date ? string : T
     [K in keyof T as T[K] extends (...args: any[]) => any ? never : K]: Plainify<T[K]>;
 } : T;
 export {};
-//# sourceMappingURL=plainify.d.ts.map

package/src/@tool-box/utils/datatypes/plainify.js

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

package/src/@tool-box/utils/datatypes/string-utils.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=string-utils.d.ts.map

package/src/@tool-box/utils/datatypes/string-utils.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// ==================== Transformação de Casing ====================
+/**
+ * Converte a string para o formato kebab-case.
+ * Separa palavras com hífen e converte tudo para minúsculas.
+ * @returns String no formato kebab-case
+ * @example
+ * "helloWorld".toKebabCase() // "hello-world"
+ * "FooBarBaz".toKebabCase() // "foo-bar-baz"
+ */
+String.prototype.toKebabCase = function () {
+    return this.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+};
+/**
+ * Converte a string para o formato snake_case.
+ * Separa palavras com underscore e converte tudo para minúsculas.
+ * @returns String no formato snake_case
+ * @example
+ * "helloWorld".toSnakeCase() // "hello_world"
+ * "FooBarBaz".toSnakeCase() // "foo_bar_baz"
+ */
+String.prototype.toSnakeCase = function () {
+    return this.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+};
+/**
+ * Converte a string para o formato camelCase.
+ * Remove espaços e capitaliza a primeira letra de cada palavra, exceto a primeira.
+ * @returns String no formato camelCase
+ * @example
+ * "hello world".toCamelCase() // "helloWorld"
+ * "foo bar baz".toCamelCase() // "fooBarBaz"
+ */
+String.prototype.toCamelCase = function () {
+    return this.valueOf()
+        .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match, index) => index === 0 ? match.toLowerCase() : match.toUpperCase())
+        .replace(/\s+/g, "");
+};
+/**
+ * Converte a string para o formato PascalCase.
+ * Remove espaços e capitaliza a primeira letra de cada palavra.
+ * @returns String no formato PascalCase
+ * @example
+ * "hello world".toPascalCase() // "HelloWorld"
+ * "foo bar baz".toPascalCase() // "FooBarBaz"
+ */
+String.prototype.toPascalCase = function () {
+    return this.valueOf()
+        .replace(/(?:^\w|[A-Z]|\b\w|\s+)/g, (match) => match.toUpperCase())
+        .replace(/\s+/g, "");
+};
+/**
+ * Converte a string para o formato Title Case.
+ * Capitaliza a primeira letra de cada palavra, mantendo as demais em minúsculo.
+ * @returns String no formato Title Case
+ * @example
+ * "hello world".toTitleCase() // "Hello World"
+ * "the quick brown fox".toTitleCase() // "The Quick Brown Fox"
+ */
+String.prototype.toTitleCase = function () {
+    return this.valueOf()
+        .toLowerCase()
+        .replace(/(?:^|\s)\w/g, (match) => match.toUpperCase());
+};
+/**
+ * Capitaliza a primeira letra de cada palavra da string.
+ * @returns String com a primeira letra de cada palavra em maiúsculo
+ * @example
+ * "hello world".capitalize() // "Hello World"
+ * "foo BAR".capitalize() // "Foo Bar"
+ */
+String.prototype.capitalize = function () {
+    return this.valueOf()
+        .split(" ")
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+};
+// ==================== Manipulação ====================
+/**
+ * Remove espaços extras e faz trim na string.
+ * Substitui múltiplos espaços consecutivos por um único espaço.
+ * @returns String sem espaços extras
+ * @example
+ * "  hello   world  ".sanitize() // "hello world"
+ * "foo  bar".sanitize() // "foo bar"
+ */
+String.prototype.sanitize = function () {
+    return this.valueOf().replace(/\s+/g, " ").trim();
+};
+/**
+ * Trunca a string para um comprimento máximo, adicionando "..." ao final.
+ * Se a string já for menor ou igual ao comprimento, retorna sem alteração.
+ * @param length - Comprimento máximo da string resultante (incluindo "...")
+ * @returns String truncada com "..." se necessário
+ * @example
+ * "Hello World".truncate(8) // "Hello..."
+ * "Hi".truncate(8) // "Hi"
+ */
+String.prototype.truncate = function (length) {
+    if (this.valueOf().length <= length)
+        return this.valueOf();
+    return `${this.valueOf().substring(0, length - 3)}...`;
+};
+/**
+ * Remove todos os espaços em branco da string.
+ * @returns String sem nenhum espaço em branco
+ * @example
+ * "hello world".removeWhitespace() // "helloworld"
+ * "  foo  bar  ".removeWhitespace() // "foobar"
+ */
+String.prototype.removeWhitespace = function () {
+    return this.valueOf().replace(/\s+/g, "");
+};
+/**
+ * Inverte os caracteres da string.
+ * @returns String com os caracteres em ordem inversa
+ * @example
+ * "hello".reverse() // "olleh"
+ * "abcd".reverse() // "dcba"
+ */
+String.prototype.reverse = function () {
+    return this.valueOf().split("").reverse().join("");
+};
+/**
+ * Preenche o início (esquerda) da string com um caractere até atingir o comprimento especificado.
+ * @param length - Comprimento total desejado da string
+ * @param char - Caractere de preenchimento (padrão: " ")
+ * @returns String preenchida à esquerda
+ * @example
+ * "5".padLeft(3, "0") // "005"
+ * "hi".padLeft(5) // "   hi"
+ */
+String.prototype.padLeft = function (length, char = " ") {
+    return this.valueOf().padStart(length, char);
+};
+/**
+ * Preenche o final (direita) da string com um caractere até atingir o comprimento especificado.
+ * @param length - Comprimento total desejado da string
+ * @param char - Caractere de preenchimento (padrão: " ")
+ * @returns String preenchida à direita
+ * @example
+ * "5".padRight(3, "0") // "500"
+ * "hi".padRight(5) // "hi   "
+ */
+String.prototype.padRight = function (length, char = " ") {
+    return this.valueOf().padEnd(length, char);
+};
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Substitui todas as ocorrências de uma substring por outra.
+ * @param search - Substring/RegExp a ser substituída
+ * @param replacement - String de substituição ou função de substituição
+ * @returns Nova string com todas as ocorrências substituídas
+ * @example
+ * "foo bar foo".replaceAll("foo", "baz") // "baz bar baz"
+ */
+String.prototype.replaceAll = function (search, replacement) {
+    const source = this.valueOf();
+    if (search instanceof RegExp) {
+        const flags = search.flags.includes("g")
+            ? search.flags
+            : `${search.flags}g`;
+        return source.replace(new RegExp(search.source, flags), replacement);
+    }
+    const literalGlobalRegex = new RegExp(escapeRegExp(search), "g");
+    return source.replace(literalGlobalRegex, replacement);
+};
+// ==================== Verificação de Conteúdo ====================
+/**
+ * Verifica se a string contém uma substring específica.
+ * @param substring - Substring a ser procurada
+ * @returns true se a substring foi encontrada, false caso contrário
+ * @example
+ * "hello world".contains("world") // true
+ * "hello world".contains("foo") // false
+ */
+String.prototype.contains = function (substring) {
+    return this.valueOf().indexOf(substring) !== -1;
+};
+/**
+ * Conta o número de ocorrências de uma substring na string.
+ * @param substring - Substring a ser contada
+ * @returns Número de ocorrências encontradas
+ * @example
+ * "hello world hello".countOccurrences("hello") // 2
+ * "aaaa".countOccurrences("aa") // 2
+ */
+String.prototype.countOccurrences = function (substring) {
+    if (substring.length === 0)
+        return 0;
+    return this.valueOf().split(substring).length - 1;
+};
+// ==================== Validações ====================
+/**
+ * Verifica se a string está vazia (sem nenhum caractere).
+ * @returns true se a string não possui caracteres, false caso contrário
+ * @example
+ * "".isEmpty() // true
+ * "hello".isEmpty() // false
+ */
+String.prototype.isEmpty = function () {
+    return this.valueOf().length === 0;
+};
+/**
+ * Verifica se a string possui conteúdo (não está vazia).
+ * @returns true se a string possui pelo menos um caractere, false caso contrário
+ * @example
+ * "hello".isFilled() // true
+ * "".isFilled() // false
+ */
+String.prototype.isFilled = function () {
+    return this.valueOf().length > 0;
+};
+/**
+ * Verifica se a string é um palíndromo (lida da mesma forma de frente para trás).
+ * @returns true se a string é um palíndromo, false caso contrário
+ * @example
+ * "racecar".isPalindrome() // true
+ * "hello".isPalindrome() // false
+ */
+String.prototype.isPalindrome = function () {
+    const clean = this.valueOf().toLowerCase().removeWhitespace();
+    return clean === clean.split("").reverse().join("");
+};
+/**
+ * Verifica se a string representa um valor numérico válido.
+ * @returns true se a string pode ser convertida para número, false caso contrário
+ * @example
+ * "42".isNumeric() // true
+ * "3.14".isNumeric() // true
+ * "hello".isNumeric() // false
+ */
+String.prototype.isNumeric = function () {
+    return !Number.isNaN(Number(this.valueOf())) && this.valueOf().isFilled();
+};
+/**
+ * Verifica se a string é um endereço de e-mail válido.
+ * @returns true se a string é um e-mail válido, false caso contrário
+ * @example
+ * "user@example.com".isEmail() // true
+ * "invalid-email".isEmail() // false
+ */
+String.prototype.isEmail = function () {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(this.valueOf());
+};
+/**
+ * Verifica se a string é uma URL válida.
+ * @returns true se a string é uma URL válida, false caso contrário
+ * @example
+ * "https://example.com".isURL() // true
+ * "not a url".isURL() // false
+ */
+String.prototype.isURL = function () {
+    try {
+        new URL(this.valueOf());
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Verifica se a string é um UUID (Universally Unique Identifier) válido.
+ * @returns true se a string é um UUID válido, false caso contrário
+ * @example
+ * "550e8400-e29b-41d4-a716-446655440000".isUUID() // true
+ * "invalid-uuid".isUUID() // false
+ */
+String.prototype.isUUID = function () {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(this.valueOf());
+};
+// ==================== Conversão ====================
+/**
+ * Converte a string para o formato Base64.
+ * @returns String codificada em Base64
+ * @example
+ * "hello".toBase64() // "aGVsbG8="
+ */
+String.prototype.toBase64 = function () {
+    return btoa(this.valueOf());
+};
+/**
+ * Decodifica a string do formato Base64.
+ * @returns String decodificada do Base64
+ * @example
+ * "aGVsbG8=".fromBase64() // "hello"
+ */
+String.prototype.fromBase64 = function () {
+    return atob(this.valueOf());
+};

package/src/@tool-box/utils/datetime/mappers/month.mapper.d.ts

@@ -1,7 +1,6 @@
-import { MonthAbbreviationEnum } from "#/@tool-box/utils/datetime/mappers/points/month-abbreviation.enum.ts";
-import { MonthNumberEnum } from "#/@tool-box/utils/datetime/mappers/points/month-number.enum.ts";
+import { MonthAbbreviationEnum } from "../../../../@tool-box/utils/datetime/mappers/points/month-abbreviation.enum";
+import { MonthNumberEnum } from "../../../../@tool-box/utils/datetime/mappers/points/month-number.enum";
 export declare class MonthMapper {
     static toNumber(monthAbbreviation: MonthAbbreviationEnum): MonthNumberEnum;
     static toAbbreviation(monthNumber: MonthNumberEnum): MonthAbbreviationEnum;
 }
-//# sourceMappingURL=month.mapper.d.ts.map

package/src/@tool-box/utils/datetime/mappers/month.mapper.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonthMapper = void 0;
+const month_abbreviation_enum_1 = require("../../../../@tool-box/utils/datetime/mappers/points/month-abbreviation.enum");
+const month_number_enum_1 = require("../../../../@tool-box/utils/datetime/mappers/points/month-number.enum");
+class MonthMapper {
+    static toNumber(monthAbbreviation) {
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.january)
+            return month_number_enum_1.MonthNumberEnum.january;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.february)
+            return month_number_enum_1.MonthNumberEnum.february;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.march)
+            return month_number_enum_1.MonthNumberEnum.march;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.april)
+            return month_number_enum_1.MonthNumberEnum.april;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.may)
+            return month_number_enum_1.MonthNumberEnum.may;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.june)
+            return month_number_enum_1.MonthNumberEnum.june;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.july)
+            return month_number_enum_1.MonthNumberEnum.july;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.august)
+            return month_number_enum_1.MonthNumberEnum.august;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.september)
+            return month_number_enum_1.MonthNumberEnum.september;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.october)
+            return month_number_enum_1.MonthNumberEnum.october;
+        if (monthAbbreviation === month_abbreviation_enum_1.MonthAbbreviationEnum.november)
+            return month_number_enum_1.MonthNumberEnum.november;
+        return month_number_enum_1.MonthNumberEnum.december;
+    }
+    static toAbbreviation(monthNumber) {
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.january)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.january;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.february)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.february;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.march)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.march;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.april)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.april;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.may)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.may;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.june)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.june;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.july)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.july;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.august)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.august;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.september)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.september;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.october)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.october;
+        if (monthNumber === month_number_enum_1.MonthNumberEnum.november)
+            return month_abbreviation_enum_1.MonthAbbreviationEnum.november;
+        return month_abbreviation_enum_1.MonthAbbreviationEnum.december;
+    }
+}
+exports.MonthMapper = MonthMapper;

package/src/@tool-box/utils/datetime/mappers/points/month-abbreviation.enum.d.ts

@@ -12,4 +12,3 @@ export declare enum MonthAbbreviationEnum {
     november = "nov",
     december = "dez"
 }
-//# sourceMappingURL=month-abbreviation.enum.d.ts.map

package/src/@tool-box/utils/datetime/mappers/points/month-abbreviation.enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonthAbbreviationEnum = void 0;
+var MonthAbbreviationEnum;
+(function (MonthAbbreviationEnum) {
+    MonthAbbreviationEnum["january"] = "jan";
+    MonthAbbreviationEnum["february"] = "fev";
+    MonthAbbreviationEnum["march"] = "mar";
+    MonthAbbreviationEnum["april"] = "abr";
+    MonthAbbreviationEnum["may"] = "mai";
+    MonthAbbreviationEnum["june"] = "jun";
+    MonthAbbreviationEnum["july"] = "jul";
+    MonthAbbreviationEnum["august"] = "ago";
+    MonthAbbreviationEnum["september"] = "set";
+    MonthAbbreviationEnum["october"] = "out";
+    MonthAbbreviationEnum["november"] = "nov";
+    MonthAbbreviationEnum["december"] = "dez";
+})(MonthAbbreviationEnum || (exports.MonthAbbreviationEnum = MonthAbbreviationEnum = {}));

package/src/@tool-box/utils/datetime/mappers/points/month-number.enum.d.ts

@@ -12,4 +12,3 @@ export declare enum MonthNumberEnum {
     november = "11",
     december = "12"
 }
-//# sourceMappingURL=month-number.enum.d.ts.map

package/src/@tool-box/utils/datetime/mappers/points/month-number.enum.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonthNumberEnum = void 0;
+var MonthNumberEnum;
+(function (MonthNumberEnum) {
+    MonthNumberEnum["january"] = "01";
+    MonthNumberEnum["february"] = "02";
+    MonthNumberEnum["march"] = "03";
+    MonthNumberEnum["april"] = "04";
+    MonthNumberEnum["may"] = "05";
+    MonthNumberEnum["june"] = "06";
+    MonthNumberEnum["july"] = "07";
+    MonthNumberEnum["august"] = "08";
+    MonthNumberEnum["september"] = "09";
+    MonthNumberEnum["october"] = "10";
+    MonthNumberEnum["november"] = "11";
+    MonthNumberEnum["december"] = "12";
+})(MonthNumberEnum || (exports.MonthNumberEnum = MonthNumberEnum = {}));

package/src/@tool-box/utils/ducts/common.d.ts

@@ -56,4 +56,3 @@ export declare function isTruthy(val: unknown): boolean;
 export type IterType<T> = T extends {
     [Symbol.iterator](): infer I;
 } ? I : unknown;
-//# sourceMappingURL=common.d.ts.map

package/src/@tool-box/utils/ducts/common.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyArray = exports.FnVal = exports.ValueReturn = exports.SuccessReturn = void 0;
+exports.isTruthy = isTruthy;
+const guardian_1 = require("../../../@tool-box/utils/type-guard/guardian");
+/**
+ * Symbol que representa o estado de sucesso em estruturas de dutos.
+ * @example
+ * const isSuccess = result[SuccessReturn];
+ */
+exports.SuccessReturn = Symbol("SuccessReturn");
+/**
+ * Symbol que representa o valor encapsulado em estruturas de dutos.
+ * @example
+ * const value = result[ValueReturn];
+ */
+exports.ValueReturn = Symbol("ValueReturn");
+/**
+ * Symbol utilitário para armazenar referência de função/valor.
+ * @example
+ * const fnHolder = { [FnVal]: () => "ok" };
+ */
+exports.FnVal = Symbol("FnVal");
+/**
+ * Array vazio imutável para reuso seguro.
+ * @example
+ * for (const item of EmptyArray) {
+ *   // não executa
+ * }
+ */
+exports.EmptyArray = Object.freeze([]);
+/**
+ * Verifica se um valor deve ser tratado como "truthy".
+ * - Para Date, valida se o timestamp é válido (não-NaN).
+ * - Para demais tipos, usa coerção booleana.
+ *
+ * @param val Valor a ser verificado.
+ * @returns true quando o valor é considerado válido/truthy.
+ * @example
+ * isTruthy("abc"); // true
+ * isTruthy(""); // false
+ * isTruthy(new Date()); // true
+ * isTruthy(new Date("invalid")); // false
+ */
+function isTruthy(val) {
+    return val instanceof Date ? guardian_1._.isEqual(val.getTime(), val.getTime()) : !!val;
+}

package/src/@tool-box/utils/ducts/optional-type.d.ts

@@ -1,4 +1,4 @@
-import { FalseyValues, IterType, SuccessReturn, ValueReturn } from "#/@tool-box/utils/ducts/common.ts";
+import { FalseyValues, IterType, SuccessReturn, ValueReturn } from "../../../@tool-box/utils/ducts/common";
 /**
  * Representa um Optional com valor presente.
  * @example
@@ -107,4 +107,3 @@ export declare function Optional<T>(val: T): Optional<From<T>>;
  */
 export declare const Nothing: Readonly<OptionalType<never>>;
 export {};
-//# sourceMappingURL=optional-type.d.ts.map