@atlantjs/arch 15.7.7 → 15.7.8

package/src/objects/amount/amount.edge.js

@@ -0,0 +1,628 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmountEdge = void 0;
+const convert_units_1 = require("../../@tool-box/utils/convert-units/convert-units");
+const guardian_1 = require("../../@tool-box/utils/type-guard/guardian");
+const amount_value_edge_1 = require("../../objects/amount/amount-value.edge");
+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");
+class AmountEdge {
+    _value;
+    _unit;
+    constructor(_value, _unit) {
+        this._value = _value;
+        this._unit = _unit;
+    }
+    get value() {
+        return this._value;
+    }
+    get unit() {
+        return this._unit;
+    }
+    // ====================
+    // Rounding and Precision
+    // ====================
+    /**
+     * Rounds the value to the nearest integer.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(5.7, MassUnitPoint.gram);
+     * amount.round(); // value is now 6
+     */
+    round() {
+        this._value = Math.round(this._value);
+        return this;
+    }
+    /**
+     * Rounds the value up to the next highest integer.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(5.2, MassUnitPoint.gram);
+     * amount.ceil(); // value is now 6
+     */
+    ceil() {
+        this._value = Math.ceil(this._value);
+        return this;
+    }
+    /**
+     * Rounds the value down to the next lowest integer.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(5.9, MassUnitPoint.gram);
+     * amount.floor(); // value is now 5
+     */
+    floor() {
+        this._value = Math.floor(this._value);
+        return this;
+    }
+    /**
+     * Rounds the value to a specified number of decimal places.
+     * @param precision - The number of decimal places to keep.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(5.6789, MassUnitPoint.gram);
+     * amount.toFixed(2); // value is now 5.68
+     */
+    toFixed(precision) {
+        this._value = Number(this._value.toFixed(precision));
+        return this;
+    }
+    /**
+     * Returns the absolute value (without sign).
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(-5.5, MassUnitPoint.gram);
+     * amount.abs(); // value is now 5.5
+     */
+    abs() {
+        this._value = Math.abs(this._value);
+        return this;
+    }
+    // ====================
+    // Unit Compaction
+    // ====================
+    /**
+     * Compacts the amount into a more appropriate unit based on its value.
+     * For example, 1000 grams is converted to 1 kilogram.
+     *
+     * @returns A new instance with the compacted unit.
+     *
+     * @example
+     * const amount = new AmountEdge(1500, MassUnitPoint.gram);
+     * const compact = amount.compact(); // 1.5 kg
+     */
+    compact() {
+        const amountValue = new amount_value_edge_1.AmountValueEdge(this._value);
+        // Mass
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, mass_unit_point_1.MassUnitPoint.gram)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toKilogram(this), mass_unit_point_1.MassUnitPoint.kilogram);
+        }
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, mass_unit_point_1.MassUnitPoint.milligram)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toGram(this), mass_unit_point_1.MassUnitPoint.gram);
+        }
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, mass_unit_point_1.MassUnitPoint.micrograma)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toMilligram(this), mass_unit_point_1.MassUnitPoint.milligram);
+        }
+        // Volume
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, volume_unit_point_1.VolumeUnitPoint.milliliter)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toLiter(this), volume_unit_point_1.VolumeUnitPoint.liter);
+        }
+        // Length
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, length_unit_point_1.LengthUnitPoint.meter)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toKilometer(this), length_unit_point_1.LengthUnitPoint.kilometer);
+        }
+        if (amountValue.isEqualOrBiggerThan(100) &&
+            guardian_1._.isEqual(this._unit, length_unit_point_1.LengthUnitPoint.centimeter)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toMeter(this), length_unit_point_1.LengthUnitPoint.meter);
+        }
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, length_unit_point_1.LengthUnitPoint.millimeter)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toMeter(this), length_unit_point_1.LengthUnitPoint.meter);
+        }
+        // Energy
+        if (amountValue.isEqualOrBiggerThan(1000) &&
+            guardian_1._.isEqual(this._unit, energy_unit_point_1.EnergyUnitPoint.calorie)) {
+            return new AmountEdge(convert_units_1.ConvertUnit.toKilocalorie(this), energy_unit_point_1.EnergyUnitPoint.kilocalorie);
+        }
+        return this;
+    }
+    // ====================
+    // Arithmetic Operations
+    // ====================
+    /**
+     * Adds another amount to the current value.
+     * @param amount - The amount to be added.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(3, MassUnitPoint.gram);
+     * amount1.sum(amount2); // value is now 8
+     */
+    sum(amount) {
+        this._value += amount.value;
+        return this;
+    }
+    /**
+     * Subtracts another amount from the current value.
+     * @param amount - The amount to be subtracted.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount1 = new AmountEdge(8, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(3, MassUnitPoint.gram);
+     * amount1.subtract(amount2); // value is now 5
+     */
+    subtract(amount) {
+        this._value -= amount.value;
+        return this;
+    }
+    /**
+     * Divides the value by a number or another amount.
+     * @param amount - Divisor (number or AmountEdge)
+     * @returns `this` to allow method chaining
+     * @example
+     * const amount = new AmountEdge(10, MassUnitPoint.gram);
+     * amount.divideBy(2); // value is now 5
+     * amount.divideBy(new AmountEdge(2, MassUnitPoint.gram)); // value is now 2.5
+     */
+    divideBy(amount) {
+        if (typeof amount === "number") {
+            this._value /= amount;
+        }
+        else {
+            this._value /= amount.value;
+        }
+        return this;
+    }
+    /**
+     * Multiplies the value by a number or another amount.
+     * @param amount - Multiplier (number or AmountEdge)
+     * @returns `this` to allow method chaining
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * amount.multiplyBy(2); // value is now 10
+     * amount.multiplyBy(new AmountEdge(3, MassUnitPoint.gram)); // value is now 30
+     */
+    multiplyBy(amount) {
+        if (typeof amount === "number") {
+            this._value *= amount;
+        }
+        else {
+            this._value *= amount.value;
+        }
+        return this;
+    }
+    /**
+     * Calculates the remainder (modulus) of the current value.
+     * @param amount - The divisor, either a number or an AmountEdge instance.
+     * @returns `this` to allow method chaining.
+     * @example
+     * const amount = new AmountEdge(10, MassUnitPoint.gram);
+     * amount.modBy(3); // value is now 1
+     */
+    modBy(amount) {
+        if (typeof amount === "number") {
+            this._value %= amount;
+        }
+        else {
+            this._value %= amount.value;
+        }
+        return this;
+    }
+    /**
+     * Calculates the absolute difference between this amount and another.
+     * @param amount - The amount to compare against
+     * @returns A new instance with the absolute difference
+     * @example
+     * const amount1 = new AmountEdge(10, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(3, MassUnitPoint.gram);
+     * const diff = amount1.difference(amount2); // 7
+     */
+    difference(amount) {
+        const diff = Math.abs(this._value - amount.value);
+        return new AmountEdge(diff, this._unit);
+    }
+    /**
+     * Applies a percentage to the current value.
+     * @param percentage - The percentage to apply (0-100)
+     * @returns `this` to allow method chaining
+     * @example
+     * const amount = new AmountEdge(100, MassUnitPoint.gram);
+     * amount.applyPercentage(20); // value is now 120 (100 + 20%)
+     */
+    applyPercentage(percentage) {
+        const percentageValue = (this._value * percentage) / 100;
+        this._value += percentageValue;
+        return this;
+    }
+    /**
+     * Calculates the percentage that this amount represents of a total.
+     * @param total - The total amount
+     * @returns The percentage as a number (0-100)
+     * @example
+     * const amount = new AmountEdge(25, MassUnitPoint.gram);
+     * const total = new AmountEdge(100, MassUnitPoint.gram);
+     * const percentage = amount.percentageOf(total); // 25
+     * @returns The percentage as a number (0-100)
+     * @example
+     * const amount = new AmountEdge(25, MassUnitPoint.gram);
+     * const total = new AmountEdge(100, MassUnitPoint.gram);
+     * const percentage = amount.percentageOf(total); // 25
+     */
+    percentageOf(total) {
+        if (total.value === 0)
+            return 0;
+        return (this._value / total.value) * 100;
+    }
+    // ====================
+    // Comparisons
+    // ====================
+    /**
+     * Checks whether this amount is equal to another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if both amounts have the same value and unit; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(5, MassUnitPoint.gram);
+     * amount1.isEqual(amount2); // true
+     */
+    isEqual(amount) {
+        return (guardian_1._.isEqual(this._value, amount.value) && guardian_1._.isEqual(this._unit, amount.unit));
+    }
+    /**
+     * Checks whether this amount is different from another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if the amounts are different; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(3, MassUnitPoint.gram);
+     * amount1.isDifferent(amount2); // true
+     */
+    isDifferent(amount) {
+        return !this.isEqual(amount);
+    }
+    /**
+     * Checks whether this amount is greater than another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if this amount's value is greater than `amount`'s value; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(10, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(5, MassUnitPoint.gram);
+     * amount1.isGreaterThan(amount2); // true
+     */
+    isGreaterThan(amount) {
+        return this._value > amount.value;
+    }
+    /**
+     * Checks whether this amount is less than another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if this amount's value is less than `amount`'s value; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(3, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(5, MassUnitPoint.gram);
+     * amount1.isLessThan(amount2); // true
+     */
+    isLessThan(amount) {
+        return this._value < amount.value;
+    }
+    /**
+     * Checks whether this amount is greater than or equal to another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if this amount's value is greater than or equal to `amount`'s value; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(5, MassUnitPoint.gram);
+     * amount1.isGreaterThanOrEqual(amount2); // true
+     */
+    isGreaterThanOrEqual(amount) {
+        return this._value >= amount.value;
+    }
+    /**
+     * Checks whether this amount is less than or equal to another amount.
+     * @param amount - The amount to compare against.
+     * @returns `true` if this amount's value is less than or equal to `amount`'s value; otherwise, `false`.
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = new AmountEdge(5, MassUnitPoint.gram);
+     * amount1.isLessThanOrEqual(amount2); // true
+     */
+    isLessThanOrEqual(amount) {
+        return this._value <= amount.value;
+    }
+    /**
+     * Checks whether this amount is between two bounds (inclusive).
+     * @param min - The minimum amount.
+     * @param max - The maximum amount.
+     * @returns `true` if the value is between min and max; otherwise, `false`.
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * const min = new AmountEdge(1, MassUnitPoint.gram);
+     * const max = new AmountEdge(10, MassUnitPoint.gram);
+     * amount.isBetween(min, max); // true
+     */
+    isBetween(min, max) {
+        return this.isGreaterThanOrEqual(min) && this.isLessThanOrEqual(max);
+    }
+    // ====================
+    // Validations
+    // ====================
+    /**
+     * Checks whether the value is zero.
+     * @returns `true` if this.value === 0, `false` otherwise
+     * @example
+     * const amount = new AmountEdge(0, MassUnitPoint.gram);
+     * amount.isZero(); // true
+     */
+    isZero() {
+        return this._value === 0;
+    }
+    /**
+     * Checks whether the value is positive (greater than zero).
+     * @returns `true` if this.value > 0, `false` otherwise
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * amount.isPositive(); // true
+     */
+    isPositive() {
+        return this._value > 0;
+    }
+    /**
+     * Checks whether the value is negative (less than zero).
+     * @returns `true` if this.value < 0, `false` otherwise
+     * @example
+     * const amount = new AmountEdge(-5, MassUnitPoint.gram);
+     * amount.isNegative(); // true
+     */
+    isNegative() {
+        return this._value < 0;
+    }
+    /**
+     * Checks whether the amount has a specific unit.
+     * @param unit - The unit to compare against.
+     * @returns `true` if the unit matches; otherwise, `false`.
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * amount.hasUnit(MassUnitPoint.gram); // true
+     * amount.hasUnit(MassUnitPoint.kilogram); // false
+     */
+    hasUnit(unit) {
+        return guardian_1._.isEqual(this._unit, unit);
+    }
+    // ====================
+    // Cloning and Immutability
+    // ====================
+    /**
+     * Creates an independent copy of this amount.
+     * Useful for avoiding unintended mutations.
+     *
+     * @returns A new instance with the same value and unit.
+     *
+     * @example
+     * const amount1 = new AmountEdge(5, MassUnitPoint.gram);
+     * const amount2 = amount1.clone();
+     * amount2.multiplyBy(2); // amount1 remains 5, amount2 is 10
+     */
+    clone() {
+        return new AmountEdge(this._value, this._unit);
+    }
+    /**
+     * Returns a new instance with the value changed.
+     * Maintains the immutability of the original instance.
+     * @param value - New value
+     * @returns New instance with the changed value
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * const newAmount = amount.withValue(10); // amount continua 5, newAmount é 10
+     */
+    withValue(value) {
+        return new AmountEdge(value, this._unit);
+    }
+    /**
+     * Returns a new instance with the unit changed.
+     * Maintains the immutability of the original instance.
+     * @param unit - New unit
+     * @returns New instance with the changed unit
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * const newAmount = amount.withUnit(MassUnitPoint.kilogram);
+     */
+    withUnit(unit) {
+        return new AmountEdge(this._value, unit);
+    }
+    // ====================
+    // Formatting
+    // ====================
+    /**
+     * Returns a string representation of the amount.
+     * @returns A string in the format "value unit".
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * amount.toString(); // "5 g"
+     */
+    toString() {
+        return `${this._value.toString()} ${this._unit}`;
+    }
+    /**
+     * Formats the amount as a string with a thousands separator and decimal precision.
+     * @param locale - Locale for formatting (e.g., 'en-US', 'pt-BR')
+     * @param precision - NNumber of decimal places
+     * @returns Formatted string
+     * @example
+     * const amount = new AmountEdge(1234.5678, MassUnitPoint.gram);
+     * amount.toFormattedString('pt-BR', 2); // "1.234,57 g"
+     */
+    toFormattedString(locale = "pt-BR", precision = 2) {
+        const formatted = this._value.toLocaleString(locale, {
+            minimumFractionDigits: precision,
+            maximumFractionDigits: precision,
+        });
+        return `${formatted} ${this._unit}`;
+    }
+    /**
+     * Returns only the value as a string with specific precision.
+     * @param precision - NNumber of decimal places
+     * @returns Formatted value string
+     * @example
+     * const amount = new AmountEdge(5.6789, MassUnitPoint.gram);
+     * amount.toValueString(2); // "5.68"
+     */
+    toValueString(precision = 2) {
+        return this._value.toFixed(precision);
+    }
+    // ====================
+    // Conversion
+    // ====================
+    /**
+     * Converts the amount to a Polygon object.
+     * @param precision - The number of decimal places to retain.
+     * @returns A Polygon object containing the value and unit.
+     * @example
+     * const amount = new AmountEdge(5.6789, MassUnitPoint.gram);
+     * amount.toPolygon(2); // { value: 5.68, unit: MassUnitPoint.gram }
+     */
+    toPolygon(precision = 2) {
+        return {
+            value: this._unit === mass_unit_point_1.MassUnitPoint.gram
+                ? Number(this._value.toFixed(0))
+                : Number(this._value.toFixed(precision)),
+            unit: this._unit,
+        };
+    }
+    /**
+     * Converts the amount to a JSON object.
+     * @returns JSON object with value and unit
+     * @example
+     * const amount = new AmountEdge(5, MassUnitPoint.gram);
+     * amount.toJSON(); // { value: 5, unit: "g" }
+     */
+    toJSON() {
+        return {
+            value: this._value,
+            unit: this._unit,
+        };
+    }
+    // ====================
+    // Static Methods
+    // ====================
+    /**
+     * Creates a new amount with a value of zero.
+     * @template T - The unit type.
+     * @param unit - The unit of the amount.
+     * @returns A new instance with a value of zero.
+     * @example
+     * const zero = AmountEdge.zero(MassUnitPoint.gram); // 0 g
+     */
+    static zero(unit) {
+        return new AmountEdge(0, unit);
+    }
+    /**
+     * Sums a list of amounts.
+     * @template T - The unit type.
+     * @param amounts - An array of amounts to sum.
+     * @returns A new instance containing the total sum.
+     * @example
+     * const amounts = [
+     *   new AmountEdge(5, MassUnitPoint.gram),
+     *   new AmountEdge(3, MassUnitPoint.gram),
+     *   new AmountEdge(2, MassUnitPoint.gram),
+     * ];
+     * const total = AmountEdge.sumAll(amounts); // 10 g
+     */
+    static sumAll(amounts) {
+        if (amounts.length === 0) {
+            throw new Error("Cannot sum an empty array of amounts");
+        }
+        const total = amounts[0].clone();
+        for (let i = 1; i < amounts.length; i++) {
+            total.sum(amounts[i]);
+        }
+        return total;
+    }
+    /**
+     * Returns the maximum amount from a list.
+     * @template T - The unit type.
+     * @param amounts - n array of amounts.
+     * @returns A new instance with the maximum value.
+     * @example
+     * const amounts = [
+     *   new AmountEdge(5, MassUnitPoint.gram),
+     *   new AmountEdge(10, MassUnitPoint.gram),
+     *   new AmountEdge(3, MassUnitPoint.gram),
+     * ];
+     * const max = AmountEdge.max(amounts); // 10 g
+     */
+    static max(amounts) {
+        if (amounts.length === 0) {
+            throw new Error("Cannot find max of an empty array of amounts");
+        }
+        let maxAmount = amounts[0].clone();
+        for (let i = 1; i < amounts.length; i++) {
+            if (amounts[i].isGreaterThan(maxAmount)) {
+                maxAmount = amounts[i].clone();
+            }
+        }
+        return maxAmount;
+    }
+    /**
+     * Returns the minimum amount from a list.
+     * @template T - The unit type.
+     * @param amounts - An array of amounts.
+     * @returns A new instance containing the smallest value.
+     * @example
+     * const amounts = [
+     *   new AmountEdge(5, MassUnitPoint.gram),
+     *   new AmountEdge(10, MassUnitPoint.gram),
+     *   new AmountEdge(3, MassUnitPoint.gram),
+     * ];
+     * const min = AmountEdge.min(amounts); // 3 g
+     */
+    static min(amounts) {
+        if (amounts.length === 0) {
+            throw new Error("Cannot find min of an empty array of amounts");
+        }
+        let minAmount = amounts[0].clone();
+        for (let i = 1; i < amounts.length; i++) {
+            if (amounts[i].isLessThan(minAmount)) {
+                minAmount = amounts[i].clone();
+            }
+        }
+        return minAmount;
+    }
+    /**
+     * Calculates the average of a list of amounts.
+     * @template T - The unit type.
+     * @param amounts - n array of amounts.
+     * @returns A new instance with the average value.
+     * @example
+     * const amounts = [
+     *   new AmountEdge(10, MassUnitPoint.gram),
+     *   new AmountEdge(20, MassUnitPoint.gram),
+     *   new AmountEdge(30, MassUnitPoint.gram),
+     * ];
+     * const average = AmountEdge.average(amounts); // 20 g
+     */
+    static average(amounts) {
+        const total = AmountEdge.sumAll(amounts);
+        total.divideBy(amounts.length);
+        return total;
+    }
+    /**
+     * Creates an amount from a Polygon object.
+     * @template T - The unit type.
+     * @param polygon - A Polygon object containing `value` and `unit`.
+     * @returns A new AmountEdge instance.
+     * @example
+     * const polygon = { value: 5, unit: MassUnitPoint.gram };
+     * const amount = AmountEdge.fromPolygon(polygon); // 5 g
+     */
+    static fromPolygon(polygon) {
+        return new AmountEdge(polygon.value, polygon.unit);
+    }
+}
+exports.AmountEdge = AmountEdge;

package/src/objects/amount/amount.polygon.d.ts

@@ -2,4 +2,3 @@ export interface AmountPolygon<UnitsPoint> {
     value: number;
     unit: UnitsPoint;
 }
-//# sourceMappingURL=amount.polygon.d.ts.map

package/src/objects/amount/amount.polygon.js

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

package/src/objects/amount/amount.uv.d.ts

@@ -1,9 +1,8 @@
-import { AmountEdge } from "#/objects/amount/amount.edge";
-import { AmountPolygon } from "#/objects/amount/amount.polygon";
-import { UvAbstract } from "#/objects-interface/uv.abstract";
+import { AmountEdge } from "../../objects/amount/amount.edge";
+import { AmountPolygon } from "../../objects/amount/amount.polygon";
+import { UvAbstract } from "../../objects-interface/uv.abstract";
 export declare class AmountUv<T> extends UvAbstract implements AmountPolygon<T> {
     value: number;
     unit: T;
     toEntity(): AmountEdge<T>;
 }
-//# sourceMappingURL=amount.uv.d.ts.map

package/src/objects/amount/amount.uv.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmountUv = void 0;
+const class_validator_1 = require("class-validator");
+const amount_edge_1 = require("../../objects/amount/amount.edge");
+const uv_abstract_1 = require("../../objects-interface/uv.abstract");
+class AmountUv extends uv_abstract_1.UvAbstract {
+    value;
+    unit;
+    toEntity() {
+        return new amount_edge_1.AmountEdge(this.value, this.unit);
+    }
+}
+exports.AmountUv = AmountUv;
+__decorate([
+    (0, class_validator_1.IsNumber)(),
+    __metadata("design:type", Number)
+], AmountUv.prototype, "value", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", Object)
+], AmountUv.prototype, "unit", void 0);

package/src/objects/amount/points/duration-unit.point.d.ts

@@ -9,4 +9,3 @@ export declare enum DurationUnitPoint {
     milliseconds = "milliseconds",
     quarters = "quarters"
 }
-//# sourceMappingURL=duration-unit.point.d.ts.map