@hahnpro/flow-sdk 4.14.4

package/dist/unit-decorators.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsElectricalFrequency = exports.IsElectricalEnergy = exports.IsElectricalPower = exports.IsThermalTransmittance = exports.IsSpecificHeatCapacity = exports.IsThermalEnergy = exports.IsHeatFlux = exports.IsMassFlow = exports.IsVolumeFlow = exports.IsDynamicViscosity = exports.IsMechanicalEnergy = exports.IsMechanicalPower = exports.IsRotatingUnbalance = exports.IsMomentOfInertia = exports.IsTorque = exports.IsRotationalDisplacement = exports.IsRotationalVelocity = exports.IsRotationalAcceleration = exports.IsSpringConstant = exports.IsTranslationalDisplacement = exports.IsTranslationalVelocity = exports.IsTranslationalAcceleration = exports.IsAngle = exports.IsVolume = exports.IsArea = exports.IsFrequency = exports.IsPressure = exports.IsPower = exports.IsEnergy = exports.IsForce = exports.IsVoltage = exports.IsLuminousIntensity = exports.IsAmountOfSubstance = exports.IsThermodynamicTemperature = exports.IsElectricCurrent = exports.IsMass = exports.IsLength = exports.IsTime = void 0;
+const unit_utils_1 = require("./unit-utils");
+const units_1 = require("./units");
+function IsTime(unit = units_1.units.time.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'time', validationOptions);
+}
+exports.IsTime = IsTime;
+function IsLength(unit = units_1.units.length.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'length', validationOptions);
+}
+exports.IsLength = IsLength;
+function IsMass(unit = units_1.units.mass.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'mass', validationOptions);
+}
+exports.IsMass = IsMass;
+function IsElectricCurrent(unit = units_1.units.electricCurrent.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'electricCurrent', validationOptions);
+}
+exports.IsElectricCurrent = IsElectricCurrent;
+function IsThermodynamicTemperature(unit = units_1.units.thermodynamicTemperature.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'thermodynamicTemperature', validationOptions);
+}
+exports.IsThermodynamicTemperature = IsThermodynamicTemperature;
+function IsAmountOfSubstance(unit = units_1.units.amountOfSubstance.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'amountOfSubstance', validationOptions);
+}
+exports.IsAmountOfSubstance = IsAmountOfSubstance;
+function IsLuminousIntensity(unit = units_1.units.luminousIntensity.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'luminousIntensity', validationOptions);
+}
+exports.IsLuminousIntensity = IsLuminousIntensity;
+function IsVoltage(unit = units_1.units.voltage.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'voltage', validationOptions);
+}
+exports.IsVoltage = IsVoltage;
+function IsForce(unit = units_1.units.force.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'force', validationOptions);
+}
+exports.IsForce = IsForce;
+function IsEnergy(unit = units_1.units.energy.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'energy', validationOptions);
+}
+exports.IsEnergy = IsEnergy;
+function IsPower(unit = units_1.units.power.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'power', validationOptions);
+}
+exports.IsPower = IsPower;
+function IsPressure(unit = units_1.units.pressure.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'pressure', validationOptions);
+}
+exports.IsPressure = IsPressure;
+function IsFrequency(unit = units_1.units.frequency.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'frequency', validationOptions);
+}
+exports.IsFrequency = IsFrequency;
+function IsArea(unit = units_1.units.area.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'area', validationOptions);
+}
+exports.IsArea = IsArea;
+function IsVolume(unit = units_1.units.volume.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'volume', validationOptions);
+}
+exports.IsVolume = IsVolume;
+function IsAngle(unit = units_1.units.angle.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'angle', validationOptions);
+}
+exports.IsAngle = IsAngle;
+function IsTranslationalAcceleration(unit = units_1.units.translationalAcceleration.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'translationalAcceleration', validationOptions);
+}
+exports.IsTranslationalAcceleration = IsTranslationalAcceleration;
+function IsTranslationalVelocity(unit = units_1.units.translationalVelocity.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'translationalVelocity', validationOptions);
+}
+exports.IsTranslationalVelocity = IsTranslationalVelocity;
+function IsTranslationalDisplacement(unit = units_1.units.translationalDisplacement.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'translationalDisplacement', validationOptions);
+}
+exports.IsTranslationalDisplacement = IsTranslationalDisplacement;
+function IsSpringConstant(unit = units_1.units.springConstant.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'springConstant', validationOptions);
+}
+exports.IsSpringConstant = IsSpringConstant;
+function IsRotationalAcceleration(unit = units_1.units.rotationalAcceleration.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'rotationalAcceleration', validationOptions);
+}
+exports.IsRotationalAcceleration = IsRotationalAcceleration;
+function IsRotationalVelocity(unit = units_1.units.rotationalVelocity.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'rotationalVelocity', validationOptions);
+}
+exports.IsRotationalVelocity = IsRotationalVelocity;
+function IsRotationalDisplacement(unit = units_1.units.rotationalDisplacement.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'rotationalDisplacement', validationOptions);
+}
+exports.IsRotationalDisplacement = IsRotationalDisplacement;
+function IsTorque(unit = units_1.units.torque.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'torque', validationOptions);
+}
+exports.IsTorque = IsTorque;
+function IsMomentOfInertia(unit = units_1.units.momentOfInertia.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'momentOfInertia', validationOptions);
+}
+exports.IsMomentOfInertia = IsMomentOfInertia;
+function IsRotatingUnbalance(unit = units_1.units.rotatingUnbalance.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'rotatingUnbalance', validationOptions);
+}
+exports.IsRotatingUnbalance = IsRotatingUnbalance;
+function IsMechanicalPower(unit = units_1.units.mechanicalPower.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'mechanicalPower', validationOptions);
+}
+exports.IsMechanicalPower = IsMechanicalPower;
+function IsMechanicalEnergy(unit = units_1.units.mechanicalEnergy.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'mechanicalEnergy', validationOptions);
+}
+exports.IsMechanicalEnergy = IsMechanicalEnergy;
+function IsDynamicViscosity(unit = units_1.units.dynamicViscosity.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'dynamicViscosity', validationOptions);
+}
+exports.IsDynamicViscosity = IsDynamicViscosity;
+function IsVolumeFlow(unit = units_1.units.volumeFlow.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'volumeFlow', validationOptions);
+}
+exports.IsVolumeFlow = IsVolumeFlow;
+function IsMassFlow(unit = units_1.units.massFlow.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'massFlow', validationOptions);
+}
+exports.IsMassFlow = IsMassFlow;
+function IsHeatFlux(unit = units_1.units.heatFlux.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'heatFlux', validationOptions);
+}
+exports.IsHeatFlux = IsHeatFlux;
+function IsThermalEnergy(unit = units_1.units.thermalEnergy.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'thermalEnergy', validationOptions);
+}
+exports.IsThermalEnergy = IsThermalEnergy;
+function IsSpecificHeatCapacity(unit = units_1.units.specificHeatCapacity.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'specificHeatCapacity', validationOptions);
+}
+exports.IsSpecificHeatCapacity = IsSpecificHeatCapacity;
+function IsThermalTransmittance(unit = units_1.units.thermalTransmittance.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'thermalTransmittance', validationOptions);
+}
+exports.IsThermalTransmittance = IsThermalTransmittance;
+function IsElectricalPower(unit = units_1.units.electricalPower.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'electricalPower', validationOptions);
+}
+exports.IsElectricalPower = IsElectricalPower;
+function IsElectricalEnergy(unit = units_1.units.electricalEnergy.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'electricalEnergy', validationOptions);
+}
+exports.IsElectricalEnergy = IsElectricalEnergy;
+function IsElectricalFrequency(unit = units_1.units.electricalFrequency.baseUnit, validationOptions) {
+    return (0, unit_utils_1.makeUnitDecorator)(unit, 'electricalFrequency', validationOptions);
+}
+exports.IsElectricalFrequency = IsElectricalFrequency;

package/dist/unit-utils.d.ts

@@ -0,0 +1,8 @@
+import { ValidationOptions } from 'class-validator';
+export declare function makeUnitDecorator(unit: string, metric: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function verifyUnit(unit: string, metric: string): number;
+export declare function computeUnitOptions(dimension: string): {
+    prefUnit: string;
+    convfactor: number;
+    offset: number;
+}[];

package/dist/unit-utils.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeUnitOptions = exports.verifyUnit = exports.makeUnitDecorator = void 0;
+const tslib_1 = require("tslib");
+const class_validator_1 = require("class-validator");
+const units_1 = require("./units");
+function makeUnitDecorator(unit, metric, validationOptions) {
+    const conversionFactor = verifyUnit(unit, metric);
+    if (conversionFactor < 0)
+        throw `${unit} is not a valid ${metric}.`;
+    return (object, propertyName) => {
+        Reflect.defineMetadata(`conversionFactor:${propertyName}`, conversionFactor, object.constructor);
+        (0, class_validator_1.registerDecorator)({
+            target: object.constructor,
+            propertyName,
+            options: validationOptions,
+            constraints: [metric, unit],
+            validator: UnitArgsValidator,
+        });
+    };
+}
+exports.makeUnitDecorator = makeUnitDecorator;
+let UnitArgsValidator = class UnitArgsValidator {
+    validate(value, validationArguments) {
+        return (0, class_validator_1.isNumber)(value);
+    }
+    defaultMessage(args) {
+        return `${args.property} must be a number conforming to the specified constraints`;
+    }
+};
+UnitArgsValidator = (0, tslib_1.__decorate)([
+    (0, class_validator_1.ValidatorConstraint)({ async: false })
+], UnitArgsValidator);
+const prefixes = [
+    { prefix: 'Y', convfactor: 1e24 },
+    { prefix: 'Z', convfactor: 1e21 },
+    { prefix: 'E', convfactor: 1e18 },
+    { prefix: 'P', convfactor: 1e15 },
+    { prefix: 'T', convfactor: 1e12 },
+    { prefix: 'G', convfactor: 1e9 },
+    { prefix: 'M', convfactor: 1e6 },
+    { prefix: 'k', convfactor: 1e3 },
+    { prefix: 'h', convfactor: 1e2 },
+    { prefix: 'da', convfactor: 1e1 },
+    { prefix: 'd', convfactor: 1e-1 },
+    { prefix: 'c', convfactor: 1e-2 },
+    { prefix: 'm', convfactor: 1e-3 },
+    { prefix: 'μ', convfactor: 1e-6 },
+    { prefix: 'n', convfactor: 1e-9 },
+    { prefix: 'p', convfactor: 1e-12 },
+    { prefix: 'f', convfactor: 1e-15 },
+    { prefix: 'a', convfactor: 1e-18 },
+    { prefix: 'z', convfactor: 1e-21 },
+    { prefix: 'y', convfactor: 1e-24 },
+];
+function verifyUnit(unit, metric) {
+    if (unit === '' || metric === '')
+        return -1;
+    const definition = units_1.units[metric];
+    for (const dimension of definition.dimensions) {
+        const components = dimension.split('*');
+        const nominator = components.filter((v) => !v.includes('-'));
+        const denominator = components.filter((v) => v.includes('-'));
+        const nomIndices = computeIndices(unit.split('/')[0], nominator);
+        const denomIndices = computeIndices(unit.split('/')[1] || '', denominator);
+        const nomFactor = verifyIndices(nomIndices, unit.split('/')[0]);
+        const denomFactor = verifyIndices(denomIndices, unit.split('/')[1]);
+        if (nomFactor > 0 && denomFactor > 0) {
+            return nomFactor / denomFactor;
+        }
+    }
+    return -1;
+}
+exports.verifyUnit = verifyUnit;
+function verifyIndices(indices, unit) {
+    if (indices.length === 0 || !unit)
+        return 1;
+    const filtered = indices
+        .map((arr) => arr.filter((v) => v.index !== -1))
+        .reduce((previousValue, currentValue) => {
+        if (currentValue.length > 1) {
+            for (let j = 0; j < currentValue.length - 1; j++) {
+                previousValue.forEach((value) => previousValue.push([...value]));
+            }
+        }
+        let index = 0;
+        while (index < previousValue.length) {
+            previousValue[index].push(currentValue[index % currentValue.length]);
+            index++;
+        }
+        return previousValue;
+    }, [[]]);
+    outer: for (const filteredElement of filtered) {
+        let index = 0;
+        let convfactor = 1;
+        while (index != unit.length) {
+            const find = filteredElement.find((obj) => (obj === null || obj === void 0 ? void 0 : obj.index) === index);
+            if (!find)
+                continue outer;
+            index += find.length;
+            convfactor *= find.convfactor;
+        }
+        return convfactor;
+    }
+    return -1;
+}
+function computeIndices(unit, dimensions) {
+    return dimensions.map((dimension) => {
+        const options = computeUnitOptions(dimension);
+        const indices = options.map((preUnit) => unit.indexOf(preUnit.prefUnit));
+        return indices.map((ind, index) => ({
+            index: ind,
+            length: options[index].prefUnit.length,
+            convfactor: options[index].convfactor,
+            offset: options[index].offset,
+        }));
+    });
+}
+function computeUnitOptions(dimension) {
+    const definition = units_1.units[units_1.dimensionToUnitMap[dimension.substring(0, 1)]];
+    const exponent = dimension.length === 1 ? 1 : Number.parseInt(dimension.substring(dimension.length - 1));
+    const withPrefixes = definition.units
+        .filter((unit) => unit.SIPrefixes)
+        .map((unit) => prefixes.map((prefix) => ({
+        prefUnit: prefix.prefix.concat(unit.unit),
+        convfactor: Math.pow(prefix.convfactor * unit.conversionFactor, exponent),
+        offset: unit.offset || 0,
+    })))
+        .reduce((prev, curr) => prev.concat(curr), []);
+    const allUnits = withPrefixes.concat(definition.units.map((unit) => ({
+        prefUnit: unit.unit,
+        convfactor: Math.pow(unit.conversionFactor, exponent),
+        offset: unit.offset || 0,
+    })));
+    return dimension.length > 1 && !dimension.endsWith('-1')
+        ? allUnits.map((unit) => ({
+            prefUnit: `${unit.prefUnit}^${dimension.substring(dimension.length - 1)}`,
+            convfactor: unit.convfactor,
+            offset: unit.offset,
+        }))
+        : allUnits;
+}
+exports.computeUnitOptions = computeUnitOptions;

package/dist/units.d.ts

@@ -0,0 +1,31 @@
+export declare const dimensionToUnitMap: {
+    T: string;
+    L: string;
+    M: string;
+    I: string;
+    Θ: string;
+    N: string;
+    J: string;
+    U: string;
+    F: string;
+    E: string;
+    W: string;
+    P: string;
+    A: string;
+    V: string;
+    f: string;
+};
+export declare const units: UnitDefinitions;
+export declare type UnitDefinitions = {
+    [key: string]: UnitDefinition;
+};
+export declare type UnitDefinition = {
+    units: {
+        unit: string;
+        conversionFactor: number;
+        SIPrefixes: boolean;
+        offset?: number;
+    }[];
+    baseUnit: string;
+    dimensions: string[];
+};