@hahnpro/flow-sdk 9.6.4 → 2025.2.0-beta.1

package/dist/flow.interface.d.ts

@@ -1,48 +0,0 @@
-import { Owner } from '@hahnpro/hpc-api';
-export interface FlowContext {
-    deploymentId?: string;
-    diagramId?: string;
-    flowId?: string;
-    owner?: Owner;
-}
-export interface FlowElementContext extends FlowContext {
-    id: string;
-    name?: string;
-    functionFqn?: string;
-    inputStreamId?: string;
-}
-export interface DeploymentMessage extends Record<string, any> {
-    elementId?: string;
-}
-interface FlowElement {
-    id: string;
-    name?: string;
-    properties?: Record<string, any>;
-    module: string;
-    functionFqn: string;
-}
-interface FlowConnection {
-    id: string;
-    name?: string;
-    source: string;
-    target: string;
-    sourceStream?: string;
-    targetStream?: string;
-}
-export interface Flow {
-    elements: FlowElement[];
-    connections: FlowConnection[];
-    modules?: string[];
-    properties?: Record<string, any>;
-    context?: FlowContext;
-}
-export interface StreamOptions {
-    concurrent?: number;
-}
-export type ClassType<T> = new (...args: any[]) => T;
-export declare enum LifecycleEvent {
-    ACTIVATED = "com.hahnpro.flow_function.activated",
-    COMPLETED = "com.hahnpro.flow_function.completed",
-    TERMINATED = "com.hahnpro.flow_function.terminated"
-}
-export {};

package/dist/flow.interface.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LifecycleEvent = void 0;
-var LifecycleEvent;
-(function (LifecycleEvent) {
-    LifecycleEvent["ACTIVATED"] = "com.hahnpro.flow_function.activated";
-    LifecycleEvent["COMPLETED"] = "com.hahnpro.flow_function.completed";
-    LifecycleEvent["TERMINATED"] = "com.hahnpro.flow_function.terminated";
-})(LifecycleEvent || (exports.LifecycleEvent = LifecycleEvent = {}));

package/dist/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IncompatableWith = exports.FlowModule = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("@hahnpro/hpc-api"), exports);
-tslib_1.__exportStar(require("./flow.interface"), exports);
-tslib_1.__exportStar(require("./utils"), exports);
-tslib_1.__exportStar(require("./FlowApplication"), exports);
-tslib_1.__exportStar(require("./FlowElement"), exports);
-tslib_1.__exportStar(require("./FlowEvent"), exports);
-tslib_1.__exportStar(require("./FlowLogger"), exports);
-var FlowModule_1 = require("./FlowModule");
-Object.defineProperty(exports, "FlowModule", { enumerable: true, get: function () { return FlowModule_1.FlowModule; } });
-tslib_1.__exportStar(require("./TestModule"), exports);
-tslib_1.__exportStar(require("./unit-decorators"), exports);
-tslib_1.__exportStar(require("./ContextManager"), exports);
-var extra_validators_1 = require("./extra-validators");
-Object.defineProperty(exports, "IncompatableWith", { enumerable: true, get: function () { return extra_validators_1.IncompatableWith; } });

package/dist/nats.d.ts

@@ -1,12 +0,0 @@
-import { ConnectionOptions, NatsConnection } from '@nats-io/nats-core';
-import { CloudEvent } from 'cloudevents';
-import { Consumer, ConsumerConfig, PubAck } from '@nats-io/jetstream';
-import { Logger } from './FlowLogger';
-export type NatsEvent<T> = Pick<CloudEvent<T>, 'type' | 'source' | 'subject' | 'data' | 'datacontenttype' | 'time'>;
-export declare const natsFlowsPrefixFlowDeployment = "fs.flowdeployment";
-export declare const defaultConsumerConfig: ConsumerConfig;
-export declare const FLOWS_STREAM_NAME = "flows";
-export declare function getOrCreateConsumer(logger: Logger, natsConnection: NatsConnection, streamName: string, consumerName: string, options: Partial<ConsumerConfig>): Promise<Consumer>;
-export declare function natsEventListener(nc: NatsConnection, logger: Logger, reconnectHandler: () => void): Promise<void>;
-export declare function publishNatsEvent<T>(logger: Logger, nc: NatsConnection, event: NatsEvent<T>, subject?: string): Promise<PubAck>;
-export declare function createNatsConnection(config: ConnectionOptions): Promise<NatsConnection>;

package/dist/nats.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FLOWS_STREAM_NAME = exports.defaultConsumerConfig = exports.natsFlowsPrefixFlowDeployment = void 0;
-exports.getOrCreateConsumer = getOrCreateConsumer;
-exports.natsEventListener = natsEventListener;
-exports.publishNatsEvent = publishNatsEvent;
-exports.createNatsConnection = createNatsConnection;
-const transport_node_1 = require("@nats-io/transport-node");
-const cloudevents_1 = require("cloudevents");
-const jetstream_1 = require("@nats-io/jetstream");
-const lodash_1 = require("lodash");
-exports.natsFlowsPrefixFlowDeployment = `fs.flowdeployment`;
-exports.defaultConsumerConfig = {
-    ack_policy: jetstream_1.AckPolicy.Explicit,
-    ack_wait: 30_000_000_000,
-    deliver_policy: jetstream_1.DeliverPolicy.All,
-    max_ack_pending: 1000,
-    max_deliver: -1,
-    max_waiting: 512,
-    replay_policy: jetstream_1.ReplayPolicy.Instant,
-    num_replicas: 0,
-};
-exports.FLOWS_STREAM_NAME = 'flows';
-async function getOrCreateConsumer(logger, natsConnection, streamName, consumerName, options) {
-    if (!natsConnection || natsConnection.isClosed()) {
-        throw new Error('NATS connection is not available');
-    }
-    else if (!streamName) {
-        throw new Error('Stream name is not available');
-    }
-    else if (!consumerName) {
-        throw new Error('Consumer name is not available');
-    }
-    logger.debug(`Creating consumer ${consumerName} for stream ${streamName}`);
-    const jsm = await (0, jetstream_1.jetstreamManager)(natsConnection);
-    const consumerInfo = await jsm.consumers.info(streamName, consumerName).catch((err) => {
-        if (err.status !== 404) {
-            logger.error(`Could not get consumer info of stream ${streamName}`, err);
-            logger.error(err.message);
-            throw err;
-        }
-    });
-    const consumerConfig = { ...exports.defaultConsumerConfig, ...options };
-    if (consumerInfo) {
-        const compared = (0, lodash_1.omitBy)(consumerConfig, (value, key) => (0, lodash_1.isEqual)(value, consumerInfo.config[key]));
-        if (Object.keys(compared).length !== 0) {
-            await jsm.consumers.update(streamName, consumerName, consumerConfig);
-        }
-    }
-    else {
-        await jsm.consumers.add(streamName, { name: consumerName, ...consumerConfig });
-    }
-    return await (0, jetstream_1.jetstream)(natsConnection).consumers.get(streamName, consumerName);
-}
-async function natsEventListener(nc, logger, reconnectHandler) {
-    const statusAsyncIterator = nc?.status();
-    if (!statusAsyncIterator) {
-        logger.error('NATS Status-AsyncIterator is not available, cannot listen for events to re-create consumers at reconnects');
-        return;
-    }
-    for await (const status of statusAsyncIterator) {
-        if (status.type === 'reconnect') {
-            reconnectHandler();
-        }
-    }
-}
-async function publishNatsEvent(logger, nc, event, subject) {
-    if (!nc || nc.isClosed()) {
-        logger.error('NATS connection is not available, cannot publish event');
-        return;
-    }
-    const cloudEvent = new cloudevents_1.CloudEvent({ datacontenttype: 'application/json', ...event });
-    cloudEvent.validate();
-    const js = (0, jetstream_1.jetstream)(nc);
-    if (js) {
-        return js.publish(subject || `${cloudEvent.type}.${cloudEvent.subject}`, JSON.stringify(cloudEvent.toJSON()), {
-            msgID: cloudEvent.id,
-        });
-    }
-    else {
-        logger.error(`Could not publish nats event, because jetstream is unavailable / undefined`);
-    }
-}
-async function createNatsConnection(config) {
-    const servers = config?.servers ?? process.env.NATS_SERVERS?.split(',') ?? [];
-    const reconnect = config?.reconnect ?? (process.env.NATS_RECONNECT ?? 'true') === 'true';
-    let maxReconnectAttempts = config?.maxReconnectAttempts ?? parseInt(process.env.NATS_MAX_RECONNECT_ATTEMPTS ?? '-1', 10);
-    if (isNaN(maxReconnectAttempts)) {
-        maxReconnectAttempts = 10;
-    }
-    let reconnectTimeWait = config?.reconnectTimeWait ?? parseInt(process.env.NATS_RECONNECT_TIME_WAIT ?? '2000', 10);
-    if (isNaN(reconnectTimeWait)) {
-        reconnectTimeWait = 2000;
-    }
-    let timeout = config?.timeout ?? parseInt(process.env.NATS_TIMEOUT ?? '2000', 10);
-    if (isNaN(timeout)) {
-        timeout = 2000;
-    }
-    const options = {
-        servers,
-        reconnect,
-        maxReconnectAttempts,
-        reconnectTimeWait,
-        timeout,
-        user: config?.user ?? process.env.NATS_USER,
-        pass: config.pass ?? process.env.NATS_PASSWORD,
-    };
-    return (0, transport_node_1.connect)(options);
-}

package/dist/unit-decorators.d.ts

@@ -1,39 +0,0 @@
-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

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

package/dist/unit-utils.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeUnitDecorator = makeUnitDecorator;
-exports.verifyUnit = verifyUnit;
-exports.computeUnitOptions = computeUnitOptions;
-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,
-        });
-    };
-}
-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;
-}
-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;
-}

package/dist/units.d.ts

@@ -1,31 +0,0 @@
-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[];
-};