@atlantjs/arch 13.2.0 → 14.0.0

package/@tool-box/utils/convert-units/convert-units.d.ts

@@ -1,11 +1,20 @@
 import { AmountEdge } from "../../../objects/amount/amount.edge";
+import { EnergyUnitPoint } from "../../../objects/amount/points/energy-unit.point";
 import { LengthUnitPoint } from "../../../objects/amount/points/length-unit.point";
 import { MassUnitPoint } from "../../../objects/amount/points/mass-unit.point";
 import { VolumeUnitPoint } from "../../../objects/amount/points/volume-unit.point";
 export declare class ConvertUnit {
-    static toKg(value: AmountEdge<MassUnitPoint>): number;
-    static toCm(value: AmountEdge<LengthUnitPoint>): number;
-    static toM(value: AmountEdge<LengthUnitPoint>): number;
-    static toL(value: AmountEdge<VolumeUnitPoint>): number;
-    static toMl(value: AmountEdge<VolumeUnitPoint>): number;
+    static toKilogram(value: AmountEdge<MassUnitPoint>): number;
+    static toGram(value: AmountEdge<MassUnitPoint>): number;
+    static toMilligram(value: AmountEdge<MassUnitPoint>): number;
+    static toMicrogram(value: AmountEdge<MassUnitPoint>): number;
+    static toKilometer(value: AmountEdge<LengthUnitPoint>): number;
+    static toCentimeter(value: AmountEdge<LengthUnitPoint>): number;
+    static toMeter(value: AmountEdge<LengthUnitPoint>): number;
+    static toMillimeter(value: AmountEdge<LengthUnitPoint>): number;
+    static toLiter(value: AmountEdge<VolumeUnitPoint>): number;
+    static toMilliliter(value: AmountEdge<VolumeUnitPoint>): number;
+    static toKilocalorie(value: AmountEdge<EnergyUnitPoint>): number;
+    static toCalorie(value: AmountEdge<EnergyUnitPoint>): number;
+    static toJoule(value: AmountEdge<EnergyUnitPoint>): number;
 }

package/@tool-box/utils/convert-units/convert-units.js

@@ -4,13 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConvertUnit = void 0;
+const convert_units_1 = __importDefault(require("convert-units"));
 const guardian_1 = require("../type-guard/guardian");
+const energy_unit_point_1 = require("../../../objects/amount/points/energy-unit.point");
 const length_unit_point_1 = require("../../../objects/amount/points/length-unit.point");
 const mass_unit_point_1 = require("../../../objects/amount/points/mass-unit.point");
 const volume_unit_point_1 = require("../../../objects/amount/points/volume-unit.point");
-const convert_units_1 = __importDefault(require("convert-units"));
 class ConvertUnit {
-    static toKg(value) {
+    // Mass
+    static toKilogram(value) {
         if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.gram)) {
             return (0, convert_units_1.default)(value.value).from("g").to("kg");
         }
@@ -22,9 +24,58 @@ class ConvertUnit {
         }
         return value.value;
     }
-    static toCm(value) {
+    static toGram(value) {
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.kilogram)) {
+            return (0, convert_units_1.default)(value.value).from("kg").to("g");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.micrograma)) {
+            return (0, convert_units_1.default)(value.value).from("mcg").to("g");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.milligram)) {
+            return (0, convert_units_1.default)(value.value).from("mg").to("g");
+        }
+        return value.value;
+    }
+    static toMilligram(value) {
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.kilogram)) {
+            return (0, convert_units_1.default)(value.value).from("kg").to("mg");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.micrograma)) {
+            return (0, convert_units_1.default)(value.value).from("mcg").to("mg");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.gram)) {
+            return (0, convert_units_1.default)(value.value).from("g").to("mg");
+        }
+        return value.value;
+    }
+    static toMicrogram(value) {
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.kilogram)) {
+            return (0, convert_units_1.default)(value.value).from("kg").to("mcg");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.milligram)) {
+            return (0, convert_units_1.default)(value.value).from("mg").to("mcg");
+        }
+        if (guardian_1._.isEqual(value.unit, mass_unit_point_1.MassUnitPoint.gram)) {
+            return (0, convert_units_1.default)(value.value).from("g").to("mcg");
+        }
+        return value.value;
+    }
+    // Length
+    static toKilometer(value) {
         if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.millimeter)) {
-            return (0, convert_units_1.default)(value.value).from("ml").to("cm");
+            return (0, convert_units_1.default)(value.value).from("mm").to("km");
+        }
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.centimeter)) {
+            return (0, convert_units_1.default)(value.value).from("cm").to("km");
+        }
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.meter)) {
+            return (0, convert_units_1.default)(value.value).from("m").to("km");
+        }
+        return value.value;
+    }
+    static toCentimeter(value) {
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.millimeter)) {
+            return (0, convert_units_1.default)(value.value).from("mm").to("cm");
         }
         if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.kilometer)) {
             return (0, convert_units_1.default)(value.value).from("km").to("cm");
@@ -34,9 +85,9 @@ class ConvertUnit {
         }
         return value.value;
     }
-    static toM(value) {
+    static toMeter(value) {
         if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.millimeter)) {
-            return (0, convert_units_1.default)(value.value).from("ml").to("m");
+            return (0, convert_units_1.default)(value.value).from("mm").to("m");
         }
         if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.kilometer)) {
             return (0, convert_units_1.default)(value.value).from("km").to("m");
@@ -46,17 +97,58 @@ class ConvertUnit {
         }
         return value.value;
     }
-    static toL(value) {
+    static toMillimeter(value) {
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.meter)) {
+            return (0, convert_units_1.default)(value.value).from("m").to("mm");
+        }
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.kilometer)) {
+            return (0, convert_units_1.default)(value.value).from("km").to("mm");
+        }
+        if (guardian_1._.isEqual(value.unit, length_unit_point_1.LengthUnitPoint.centimeter)) {
+            return (0, convert_units_1.default)(value.value).from("cm").to("mm");
+        }
+        return value.value;
+    }
+    // Volume
+    static toLiter(value) {
         if (guardian_1._.isEqual(value.unit, volume_unit_point_1.VolumeUnitPoint.milliliter)) {
             return (0, convert_units_1.default)(value.value).from("ml").to("l");
         }
         return value.value;
     }
-    static toMl(value) {
+    static toMilliliter(value) {
         if (guardian_1._.isEqual(value.unit, volume_unit_point_1.VolumeUnitPoint.liter)) {
             return (0, convert_units_1.default)(value.value).from("l").to("ml");
         }
         return value.value;
     }
+    // Energy
+    static toKilocalorie(value) {
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.calorie)) {
+            return value.value / 1000;
+        }
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.joule)) {
+            return value.value / 4184;
+        }
+        return value.value;
+    }
+    static toCalorie(value) {
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.kilocalorie)) {
+            return value.value * 1000;
+        }
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.joule)) {
+            return value.value / 4.184;
+        }
+        return value.value;
+    }
+    static toJoule(value) {
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.kilocalorie)) {
+            return value.value * 4184;
+        }
+        if (guardian_1._.isEqual(value.unit, energy_unit_point_1.EnergyUnitPoint.calorie)) {
+            return value.value * 4.184;
+        }
+        return value.value;
+    }
 }
 exports.ConvertUnit = ConvertUnit;

package/@tool-box/utils/datatypes/boolean-utils.d.ts

@@ -6,4 +6,11 @@ interface Boolean {
     not(): boolean;
     and(value: boolean): boolean;
     or(value: boolean): boolean;
+    xor(value: boolean): boolean;
+    nand(value: boolean): boolean;
+    nor(value: boolean): boolean;
+    implies(value: boolean): boolean;
+    toNumber(): number;
+    toString(): string;
+    toggle(): boolean;
 }

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

@@ -1,22 +1,164 @@
 "use strict";
+/**
+ * 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 === true;
+    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 === false || this === undefined;
+    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 === 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 !== 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;
+};
+/**
+ * Converte o valor booleano para string.
+ * @returns "true" se o valor é true, "false" se o valor é false
+ * @example
+ * (true).toString() // "true"
+ * (false).toString() // "false"
+ */
+Boolean.prototype.toString = function () {
+    return this.valueOf() ? "true" : "false";
+};
+/**
+ * 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/@tool-box/utils/datatypes/string-utils.d.ts

@@ -1,14 +1,30 @@
 interface String {
     toKebabCase(): string;
     toSnakeCase(): string;
+    toCamelCase(): string;
     toPascalCase(): string;
-    sanitize(): string;
-    capitalize(): string;
     toTitleCase(): string;
-    contains(substring: string): boolean;
-    truncate(length: number): String;
+    capitalize(): string;
+    sanitize(): string;
+    truncate(length: number): string;
     removeWhitespace(): string;
+    contains(substring: string): boolean;
+    startsWith(substring: string): boolean;
+    endsWith(substring: string): boolean;
     isEmpty(): boolean;
     isFilled(): boolean;
+    isPalindrome(): boolean;
+    isNumeric(): boolean;
+    isEmail(): boolean;
+    isURL(): boolean;
+    isUUID(): boolean;
+    countOccurrences(substring: string): number;
+    toBase64(): string;
     fromBase64(): string;
+    reverse(): string;
+    repeat(times: number): string;
+    padStart(length: number, char?: string): string;
+    padEnd(length: number, char?: string): string;
+    replaceAll(search: string | RegExp, replacement: string | ((substring: string, ...args: any[]) => string)): string;
 }
+declare function escapeRegExp(value: string): string;