@atlantjs/arch 15.7.6 → 15.7.8

package/src/objects/primitives/boolean.edge.sketch.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanEdgeSketch = void 0;
+class BooleanEdgeSketch {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    // ==================== Getters ====================
+    /**
+     * Retorna o valor booleano interno.
+     * @returns Booleano interno do edge
+     * @example
+     * new MyBooleanEdge(true).toPoint() // true
+     */
+    toBoolean() {
+        return this.value;
+    }
+    /**
+     * Retorna o valor como string.
+     * @returns "true" ou "false"
+     * @example
+     * new MyBooleanEdge(true).toString() // "true"
+     * new MyBooleanEdge(false).toString() // "false"
+     */
+    toString() {
+        return String(this.value);
+    }
+    /**
+     * Retorna o valor como número (1 para true, 0 para false).
+     * @returns 1 se true, 0 se false
+     * @example
+     * new MyBooleanEdge(true).toNumber() // 1
+     * new MyBooleanEdge(false).toNumber() // 0
+     */
+    toNumber() {
+        return this.value ? 1 : 0;
+    }
+    // ==================== Comparações ====================
+    /**
+     * Verifica se este valor é igual a outro.
+     * @param value - Booleano ou BooleanEdgeSketch para comparação
+     * @returns true se os valores são iguais, false caso contrário
+     * @example
+     * new MyBooleanEdge(true).isEqual(true) // true
+     * new MyBooleanEdge(true).isEqual(false) // false
+     */
+    isEqual(value) {
+        const comparand = value instanceof BooleanEdgeSketch ? value.toBoolean() : value;
+        return this.value === comparand;
+    }
+    /**
+     * Verifica se este valor é diferente de outro.
+     * @param value - Booleano ou BooleanEdgeSketch para comparação
+     * @returns true se os valores são diferentes, false caso contrário
+     * @example
+     * new MyBooleanEdge(true).isDifferent(false) // true
+     * new MyBooleanEdge(true).isDifferent(true) // false
+     */
+    isDifferent(value) {
+        const comparand = value instanceof BooleanEdgeSketch ? value.toBoolean() : value;
+        return this.value !== comparand;
+    }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se o valor é true.
+     * @returns true se o valor interno é true, false caso contrário
+     * @example
+     * new MyBooleanEdge(true).isTrue() // true
+     * new MyBooleanEdge(false).isTrue() // false
+     */
+    isTrue() {
+        return this.value === true;
+    }
+    /**
+     * Verifica se o valor é false.
+     * @returns true se o valor interno é false, false caso contrário
+     * @example
+     * new MyBooleanEdge(false).isFalse() // true
+     * new MyBooleanEdge(true).isFalse() // false
+     */
+    isFalse() {
+        return this.value === false;
+    }
+    // ==================== Operações Lógicas ====================
+    /**
+     * Retorna o valor negado (NOT lógico).
+     * @returns Negação do valor interno
+     * @example
+     * new MyBooleanEdge(true).negate() // false
+     * new MyBooleanEdge(false).negate() // true
+     */
+    negate() {
+        return !this.value;
+    }
+    /**
+     * Realiza AND lógico entre este valor e outro.
+     * @param value - Booleano ou BooleanEdgeSketch para operação
+     * @returns Resultado do AND lógico
+     * @example
+     * new MyBooleanEdge(true).and(true) // true
+     * new MyBooleanEdge(true).and(false) // false
+     * new MyBooleanEdge(false).and(true) // false
+     */
+    and(value) {
+        const operand = value instanceof BooleanEdgeSketch ? value.toBoolean() : value;
+        return this.value && operand;
+    }
+    /**
+     * Realiza OR lógico entre este valor e outro.
+     * @param value - Booleano ou BooleanEdgeSketch para operação
+     * @returns Resultado do OR lógico
+     * @example
+     * new MyBooleanEdge(true).or(false) // true
+     * new MyBooleanEdge(false).or(false) // false
+     * new MyBooleanEdge(false).or(true) // true
+     */
+    or(value) {
+        const operand = value instanceof BooleanEdgeSketch ? value.toBoolean() : value;
+        return this.value || operand;
+    }
+    /**
+     * Realiza XOR lógico (OU exclusivo) entre este valor e outro.
+     * @param value - Booleano ou BooleanEdgeSketch para operação
+     * @returns true se os valores são diferentes, false se iguais
+     * @example
+     * new MyBooleanEdge(true).xor(false) // true
+     * new MyBooleanEdge(true).xor(true) // false
+     * new MyBooleanEdge(false).xor(false) // false
+     */
+    xor(value) {
+        const operand = value instanceof BooleanEdgeSketch ? value.toBoolean() : value;
+        return this.value !== operand;
+    }
+    /**
+     * Retorna um valor baseado no estado booleano (ternário tipado).
+     * @param onTrue - Valor retornado se true
+     * @param onFalse - Valor retornado se false
+     * @returns onTrue se value é true, onFalse caso contrário
+     * @example
+     * new MyBooleanEdge(true).fold("yes", "no") // "yes"
+     * new MyBooleanEdge(false).fold("yes", "no") // "no"
+     */
+    fold(onTrue, onFalse) {
+        return this.value ? onTrue : onFalse;
+    }
+}
+exports.BooleanEdgeSketch = BooleanEdgeSketch;

package/src/objects/primitives/datetime.edge.sketch.d.ts

@@ -1,4 +1,3 @@
-import { DatetimeEdge } from "#/objects/datetime/edges/datetime.edge.ts";
+import { DatetimeEdge } from "../../objects/datetime/edges/datetime.edge";
 export declare abstract class DatetimeEdgeSketch extends DatetimeEdge {
 }
-//# sourceMappingURL=datetime.edge.sketch.d.ts.map

package/src/objects/primitives/datetime.edge.sketch.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatetimeEdgeSketch = void 0;
+const datetime_edge_1 = require("../../objects/datetime/edges/datetime.edge");
+class DatetimeEdgeSketch extends datetime_edge_1.DatetimeEdge {
+}
+exports.DatetimeEdgeSketch = DatetimeEdgeSketch;

package/src/objects/primitives/number.edge.sketch.d.ts

@@ -247,4 +247,3 @@ export declare abstract class NumberEdgeSketch {
      */
     private validate;
 }
-//# sourceMappingURL=number.edge.sketch.d.ts.map

package/src/objects/primitives/number.edge.sketch.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberEdgeSketch = void 0;
+const guardian_1 = require("../../@tool-box/utils/type-guard/guardian");
+class NumberEdgeSketch {
+    value;
+    constructor(value) {
+        this.value = value;
+        this.validate(value);
+    }
+    // ==================== Getters ====================
+    /**
+     * Retorna o valor numérico interno.
+     * @returns Número interno do edge
+     * @example
+     * new MyNumberEdge(42).toNumber() // 42
+     */
+    toNumber() {
+        return this.value;
+    }
+    /**
+     * Retorna o valor como string.
+     * @returns String representando o número
+     * @example
+     * new MyNumberEdge(42).toString() // "42"
+     */
+    toString() {
+        return String(this.value);
+    }
+    /**
+     * Retorna o valor absoluto do número.
+     * @returns Valor absoluto (sempre positivo)
+     * @example
+     * new MyNumberEdge(-5).toAbsolute() // 5
+     * new MyNumberEdge(5).toAbsolute() // 5
+     */
+    toAbsolute() {
+        return Math.abs(this.value);
+    }
+    /**
+     * Retorna o número fixado com casas decimais.
+     * @param decimalPlaces - Número de casas decimais (padrão: 2)
+     * @returns String com o número formatado
+     * @example
+     * new MyNumberEdge(3.14159).toFixed(2) // "3.14"
+     * new MyNumberEdge(3).toFixed(2) // "3.00"
+     */
+    toFixed(decimalPlaces = 2) {
+        return this.value.toFixed(decimalPlaces);
+    }
+    // ==================== Comparações ====================
+    /**
+     * Verifica se este valor é igual a outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se os valores são iguais, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isEqual(5) // true
+     * new MyNumberEdge(5).isEqual(6) // false
+     */
+    isEqual(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value === comparand;
+    }
+    /**
+     * Verifica se este valor é diferente de outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se os valores são diferentes, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isDifferent(6) // true
+     * new MyNumberEdge(5).isDifferent(5) // false
+     */
+    isDifferent(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value !== comparand;
+    }
+    /**
+     * Verifica se este valor é maior que outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se this > value, false caso contrário
+     * @example
+     * new MyNumberEdge(10).isBiggerThan(5) // true
+     * new MyNumberEdge(3).isBiggerThan(5) // false
+     */
+    isBiggerThan(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value > comparand; // 🐛 fix: estava value.toNumber() > this.value (invertido)
+    }
+    /**
+     * Verifica se este valor é menor que outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se this < value, false caso contrário
+     * @example
+     * new MyNumberEdge(3).isSmallerThan(5) // true
+     * new MyNumberEdge(10).isSmallerThan(5) // false
+     */
+    isSmallerThan(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value < comparand; // 🐛 fix: estava value.toNumber() < this.value (invertido)
+    }
+    /**
+     * Verifica se este valor é maior ou igual a outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se this >= value, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isEqualOrBiggerThan(5) // true
+     * new MyNumberEdge(6).isEqualOrBiggerThan(5) // true
+     * new MyNumberEdge(4).isEqualOrBiggerThan(5) // false
+     */
+    isEqualOrBiggerThan(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value >= comparand; // 🐛 fix: estava value.toNumber() >= this.value (invertido)
+    }
+    /**
+     * Verifica se este valor é menor ou igual a outro.
+     * @param value - Número ou NumberEdgeSketch para comparação
+     * @returns true se this <= value, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isEqualOrSmallerThan(5) // true
+     * new MyNumberEdge(4).isEqualOrSmallerThan(5) // true
+     * new MyNumberEdge(6).isEqualOrSmallerThan(5) // false
+     */
+    isEqualOrSmallerThan(value) {
+        const comparand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value <= comparand; // 🐛 fix: estava value.toNumber() <= this.value (invertido)
+    }
+    /**
+     * Verifica se este valor está entre dois limites (inclusivo).
+     * @param min - Limite mínimo
+     * @param max - Limite máximo
+     * @returns true se min <= this <= max, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isBetween(1, 10) // true
+     * new MyNumberEdge(15).isBetween(1, 10) // false
+     */
+    isBetween(min, max) {
+        const minimus = min instanceof NumberEdgeSketch ? min.toNumber() : min;
+        const maximus = max instanceof NumberEdgeSketch ? max.toNumber() : max;
+        return guardian_1._.isBetween(this.value, minimus, maximus);
+    }
+    // ==================== Verificações ====================
+    /**
+     * Verifica se o número é positivo (maior que zero).
+     * @returns true se o número é positivo, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isPositive() // true
+     * new MyNumberEdge(-5).isPositive() // false
+     * new MyNumberEdge(0).isPositive() // false
+     */
+    isPositive() {
+        return this.value > 0;
+    }
+    /**
+     * Verifica se o número é negativo (menor que zero).
+     * @returns true se o número é negativo, false caso contrário
+     * @example
+     * new MyNumberEdge(-5).isNegative() // true
+     * new MyNumberEdge(5).isNegative() // false
+     * new MyNumberEdge(0).isNegative() // false
+     */
+    isNegative() {
+        return this.value < 0;
+    }
+    /**
+     * Verifica se o número é zero.
+     * @returns true se o número é zero, false caso contrário
+     * @example
+     * new MyNumberEdge(0).isZero() // true
+     * new MyNumberEdge(1).isZero() // false
+     */
+    isZero() {
+        return this.value === 0;
+    }
+    /**
+     * Verifica se o número é inteiro (sem casas decimais).
+     * @returns true se o número é inteiro, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isInteger() // true
+     * new MyNumberEdge(5.5).isInteger() // false
+     */
+    isInteger() {
+        return Number.isInteger(this.value);
+    }
+    /**
+     * Verifica se o número é float (possui casas decimais).
+     * @returns true se o número é float, false caso contrário
+     * @example
+     * new MyNumberEdge(5.5).isFloat() // true
+     * new MyNumberEdge(5).isFloat() // false
+     */
+    isFloat() {
+        return !Number.isInteger(this.value);
+    }
+    /**
+     * Verifica se o número é par.
+     * @returns true se o número é par, false caso contrário
+     * @example
+     * new MyNumberEdge(4).isEven() // true
+     * new MyNumberEdge(5).isEven() // false
+     */
+    isEven() {
+        return this.value % 2 === 0;
+    }
+    /**
+     * Verifica se o número é ímpar.
+     * @returns true se o número é ímpar, false caso contrário
+     * @example
+     * new MyNumberEdge(5).isOdd() // true
+     * new MyNumberEdge(4).isOdd() // false
+     */
+    isOdd() {
+        return this.value % 2 !== 0;
+    }
+    // ==================== Operações Aritméticas ====================
+    /**
+     * Soma este valor com outro e retorna o resultado.
+     * @param value - Número ou NumberEdgeSketch a somar
+     * @returns Resultado da soma
+     * @example
+     * new MyNumberEdge(5).add(3) // 8
+     */
+    add(value) {
+        const operand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value + operand;
+    }
+    /**
+     * Subtrai outro valor deste e retorna o resultado.
+     * @param value - Número ou NumberEdgeSketch a subtrair
+     * @returns Resultado da subtração
+     * @example
+     * new MyNumberEdge(10).subtract(3) // 7
+     */
+    subtract(value) {
+        const operand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value - operand;
+    }
+    /**
+     * Multiplica este valor por outro e retorna o resultado.
+     * @param value - Número ou NumberEdgeSketch a multiplicar
+     * @returns Resultado da multiplicação
+     * @example
+     * new MyNumberEdge(5).multiply(3) // 15
+     */
+    multiply(value) {
+        const operand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        return this.value * operand;
+    }
+    /**
+     * Divide este valor por outro e retorna o resultado.
+     * @param value - Número ou NumberEdgeSketch divisor
+     * @returns Resultado da divisão
+     * @throws {Error} Se o divisor for zero
+     * @example
+     * new MyNumberEdge(10).divide(2) // 5
+     */
+    divide(value) {
+        const operand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        if (operand === 0) {
+            throw new Error(`${this.constructor.name}: division by zero is not allowed.`);
+        }
+        return this.value / operand;
+    }
+    /**
+     * Retorna o resto da divisão deste valor por outro.
+     * @param value - Número ou NumberEdgeSketch divisor
+     * @returns Resto da divisão
+     * @throws {Error} Se o divisor for zero
+     * @example
+     * new MyNumberEdge(10).modulo(3) // 1
+     */
+    modulo(value) {
+        const operand = value instanceof NumberEdgeSketch ? value.toNumber() : value;
+        if (operand === 0) {
+            throw new Error(`${this.constructor.name}: modulo by zero is not allowed.`);
+        }
+        return this.value % operand;
+    }
+    /**
+     * Eleva este valor à potência de outro.
+     * @param exponent - Expoente da potenciação
+     * @returns Resultado da potenciação
+     * @throws {TypeError} Se o expoente não for finito
+     * @example
+     * new MyNumberEdge(2).power(8) // 256
+     * new MyNumberEdge(5).power(2) // 25
+     */
+    power(exponent) {
+        if (!Number.isFinite(exponent)) {
+            throw new TypeError(`${this.constructor.name}: exponent should be a finite number.`);
+        }
+        return this.value ** exponent;
+    }
+    /**
+     * Retorna a raiz quadrada do número.
+     * @returns Raiz quadrada do valor
+     * @throws {Error} Se o número for negativo
+     * @example
+     * new MyNumberEdge(9).sqrt() // 3
+     * new MyNumberEdge(16).sqrt() // 4
+     */
+    sqrt() {
+        if (this.value < 0) {
+            throw new Error(`${this.constructor.name}: cannot calculate sqrt of a negative number.`);
+        }
+        return Math.sqrt(this.value);
+    }
+    /**
+     * Arredonda o número para o inteiro mais próximo.
+     * @returns Número arredondado
+     * @example
+     * new MyNumberEdge(4.5).round() // 5
+     * new MyNumberEdge(4.4).round() // 4
+     */
+    round() {
+        return Math.round(this.value);
+    }
+    /**
+     * Arredonda o número para baixo (floor).
+     * @returns Maior inteiro menor ou igual ao número
+     * @example
+     * new MyNumberEdge(4.9).floor() // 4
+     * new MyNumberEdge(-4.1).floor() // -5
+     */
+    floor() {
+        return Math.floor(this.value);
+    }
+    /**
+     * Arredonda o número para cima (ceil).
+     * @returns Menor inteiro maior ou igual ao número
+     * @example
+     * new MyNumberEdge(4.1).ceil() // 5
+     * new MyNumberEdge(-4.9).ceil() // -4
+     */
+    ceil() {
+        return Math.ceil(this.value);
+    }
+    // ==================== Privados ====================
+    /**
+     * Valida se o valor fornecido no construtor é um número válido.
+     * @throws {TypeError} Se o valor for NaN
+     */
+    validate(value) {
+        if (Number.isNaN(value)) {
+            throw new TypeError(`${this.constructor.name} should be valid.`);
+        }
+    }
+}
+exports.NumberEdgeSketch = NumberEdgeSketch;

package/src/objects/primitives/string.edge.sketch.d.ts

@@ -156,4 +156,3 @@ export declare abstract class StringEdgeSketch {
      */
     private validate;
 }
-//# sourceMappingURL=string.edge.sketch.d.ts.map