@hahnpro/flow-sdk 5.0.0-0 → 5.0.0

package/dist/rpc_server.py

@@ -1,104 +1,116 @@
+import asyncio
 import json
+from asyncio import Future
+from functools import partial, wraps
+from aio_pika import IncomingMessage, Exchange, Message, connect_robust, ExchangeType
+from aio_pika.abc import AbstractRobustExchange
 import os
-from functools import wraps
 
-import pika
+user = os.getenv("RABBIT_USER", "guest")
+password = os.getenv("RABBIT_PASSWORD", "guest")
+host = os.getenv("RABBIT_HOST", "localhost")
+port = os.getenv("RABBIT_PORT", "5672")
+vhost = os.getenv("RABBIT_VHOST", "")
+routingKey = os.getenv("RPC_ROUTING_KEY", "rpc")
+max_msg_size = int(os.getenv("MAX_RPC_MSG_SIZE_BYTES", "0"))
 
-host = ""
-try:
-    host = os.environ["RABBIT_HOST"]
-except:
-    host = "localhost"
-
-port = ""
-try:
-    port = os.environ["RABBIT_PORT"]
-except:
-    port = "5672"
-
-routingKey = ""
-try:
-    routingKey = os.environ["RPC_ROUTING_KEY"]
-except:
-    routingKey = "rpc"
-
-remoteProcedures = {}
+remote_procedures = {}
+flow_logs_exchange: AbstractRobustExchange
 
 
 def RemoteProcedure(func):
-    global remoteProcedures
+    global remote_procedures
 
     @wraps(func)
     def function_wrapper(*args, **kwargs):
         return func(*args, **kwargs)
 
-    remoteProcedures[func.__name__] = func
+    remote_procedures[func.__name__] = func
 
     return function_wrapper
 
 
-class PikaMassenger:
-    def __init__(self, routingKey, *args, **kwargs):
-        self.conn = pika.BlockingConnection(
-            pika.ConnectionParameters(host=host, port=port)
-        )
-        self.channel = self.conn.channel()
-        self.routingKey = routingKey
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
+
+async def on_message(exchange: Exchange, message: IncomingMessage):
+    def callback(future: Future):
+        try:
+            res = future.result()
+            if type(res) is tuple and type(res[1]) is type and issubclass(res[1], json.JSONEncoder):
+                res = json.dumps(res[0], cls=res[1])
+            reply1 = {"type": "reply", "value": res}
+        except Exception as err:
+            # print(traceback.format_list(traceback.extract_stack(err)))
+            reply1 = {"type": "error", "message": str(err), "stack": "failed"}
+
+        asyncio.ensure_future(send_reply(exchange, reply1, message), loop=loop)
+
+
+    request = json.loads(message.body.decode())
 
-    def consume(self, callback):
-        self.channel.exchange_declare(
-            exchange="rpc_direct_exchange", exchange_type="direct"
-        )
+    # call function
+    if remote_procedures.keys().__contains__(request["functionName"]):
+        func = remote_procedures.get(request["functionName"])
+        future = loop.run_in_executor(None, func, *request["arguments"])
+        future.add_done_callback(callback)
 
-        result = self.channel.queue_declare("", exclusive=True)
-        queue_name = result.method.queue
+    else:
+        reply = {
+            "type": "error",
+            "message": request["functionName"] + " is not a function",
+        }
+        await send_reply(exchange, reply, original_message=message)
 
-        self.channel.queue_bind(
-            exchange="rpc_direct_exchange",
-            queue=queue_name,
-            routing_key=self.routingKey,
-        )
 
-        self.channel.basic_consume(queue=queue_name, on_message_callback=callback)
+async def send_reply(exchange: Exchange, reply, original_message: Message):
+    body = json.dumps(reply).encode("utf-8")
 
-        self.channel.start_consuming()
+    if max_msg_size > 0 and len(body) > max_msg_size:
+        body = json.dumps(
+            {
+                "type": "error",
+                "message": "Max RPC message size exceeded: " + str(len(body)) + " bytes / " + max_msg_size + " bytes",
+            }
+        ).encode("utf-8")
 
-    def __enter__(self):
-        return self
+    await exchange.publish(
+        Message(body=body, correlation_id=original_message.correlation_id),
+        routing_key=original_message.reply_to,
+    )
 
-    def __exit__(self, exc_type, exc_value, traceback):
-        self.conn.close()
+
+async def main(loop, routing_key):
+    global flow_logs_exchange
+
+    url = "amqp://%s:%s@%s:%s/%s" % (user, password, host, port, vhost)
+    connection = await connect_robust(
+        url, loop=loop
+    )
+
+    channel = await connection.channel()
+
+    dest_exchange = await channel.declare_exchange(name="rpc_direct_exchange", type=ExchangeType.DIRECT)
+    flow_logs_exchange = await channel.declare_exchange(name='flowlogs', type=ExchangeType.FANOUT, durable=True)
+
+    queue = await channel.declare_queue("", exclusive=True)
+
+    await queue.bind(dest_exchange, routing_key)
+
+    await queue.consume(partial(
+        on_message, channel.default_exchange)
+    )
 
 
 def start_consumer(routing_key=routingKey):
-    def callback(ch, method, props, body):
-        reply = ""
-        try:
-            request = json.loads(body)
-
-            # call function
-            if remoteProcedures.keys().__contains__(request["functionName"]):
-                func = remoteProcedures.get(request["functionName"])
-                res = func(*request["arguments"])
-                reply = {"type": "reply", "value": res}
-            else:
-                reply = {
-                    "type": "error",
-                    "message": request["functionName"] + " is not a function",
-                }
+    loop.create_task(main(loop, routing_key))
+    loop.run_forever()
 
-        except Exception as err:
-            # print(traceback.format_list(traceback.extract_stack(err)))
-            reply = {"type": "error", "message": str(err), "stack": "failed"}
-        finally:
-            # print(props)
-            ch.basic_publish(
-                exchange="",
-                routing_key=props.reply_to,
-                properties=pika.BasicProperties(correlation_id=props.correlation_id),
-                body=json.dumps(reply),
-            )
-            ch.basic_ack(delivery_tag=method.delivery_tag)
-
-    with PikaMassenger(routing_key) as consumer:
-        consumer.consume(callback=callback)
+def log(message):
+    global flow_logs_exchange
+
+    if flow_logs_exchange is not None:
+        flow_logs_exchange.publish(Message(body=json.dumps(message).encode("utf-8")), "")
+    else:
+        print("Connection not established. Call start_consumer first.")

package/dist/unit-decorators.d.ts

@@ -0,0 +1,39 @@
+import { ValidationOptions } from 'class-validator';
+export declare function IsTime(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsLength(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMass(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricCurrent(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermodynamicTemperature(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsAmountOfSubstance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsLuminousIntensity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVoltage(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsForce(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsPressure(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsFrequency(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsArea(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVolume(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsAngle(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalAcceleration(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalVelocity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTranslationalDisplacement(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsSpringConstant(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalAcceleration(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalVelocity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotationalDisplacement(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsTorque(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMomentOfInertia(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsRotatingUnbalance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMechanicalPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMechanicalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsDynamicViscosity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsVolumeFlow(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsMassFlow(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsHeatFlux(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsSpecificHeatCapacity(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsThermalTransmittance(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalPower(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalEnergy(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare function IsElectricalFrequency(unit?: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

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,144 @@
+"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 new Error(`${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 = 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?.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), 10);
+    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 type UnitDefinitions = {
+    [key: string]: UnitDefinition;
+};
+export type UnitDefinition = {
+    units: {
+        unit: string;
+        conversionFactor: number;
+        SIPrefixes: boolean;
+        offset?: number;
+    }[];
+    baseUnit: string;
+    dimensions: string[];
+};