@grnsft/if 0.7.0 → 0.7.2

package/build/if-run/builtins/interpolation/index.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interpolation = void 0;
+const typescript_cubic_spline_1 = __importDefault(require("typescript-cubic-spline"));
+const zod_1 = require("zod");
+const types_1 = require("@grnsft/if-core/types");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { X_Y_EQUAL, ARRAY_LENGTH_NON_EMPTY, WITHIN_THE_RANGE, MISSING_CONFIG } = config_1.STRINGS;
+const { ConfigError } = utils_1.ERRORS;
+exports.Interpolation = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const schema = zod_1.z
+            .object({
+            method: zod_1.z.nativeEnum(types_1.Method),
+            x: zod_1.z.array(zod_1.z.number()),
+            y: zod_1.z.array(zod_1.z.number()),
+            'input-parameter': zod_1.z.string(),
+            'output-parameter': zod_1.z.string(),
+        })
+            .refine(data => data.x && data.y && data.x.length === data.y.length, {
+            message: X_Y_EQUAL,
+        })
+            .refine(data => data.x.length > 1 && data.y.length > 1, {
+            message: ARRAY_LENGTH_NON_EMPTY,
+        });
+        const defaultMethod = config.method ?? types_1.Method.LINEAR;
+        const updatedConfig = Object.assign({}, { method: defaultMethod }, config, {
+            x: sortPoints(config.x),
+            y: sortPoints(config.y),
+        });
+        return (0, validations_1.validate)(schema, updatedConfig);
+    },
+    inputValidation: (input, config, index) => {
+        const inputParameter = config['input-parameter'];
+        const schema = zod_1.z
+            .object({
+            timestamp: zod_1.z.string().or(zod_1.z.date()),
+            duration: zod_1.z.number(),
+            [inputParameter]: zod_1.z.number().gte(0).or(zod_1.z.literal('off')),
+        })
+            .refine(data => (data[inputParameter] >= config.x[0] &&
+            data[inputParameter] <= config.x[config.x.length - 1]) ||
+            data[inputParameter] === 'off', {
+            message: WITHIN_THE_RANGE,
+        });
+        return (0, validations_1.validate)(schema, input, index);
+    },
+    implementation: async (inputs, config) => {
+        const { 'input-parameter': inputParameter, 'output-parameter': outputParameter, } = config;
+        return inputs.map(input => {
+            if (input[inputParameter] === 'off') {
+                return {
+                    ...input,
+                    [inputParameter]: 0,
+                    [outputParameter]: 0,
+                };
+            }
+            return {
+                ...input,
+                [outputParameter]: calculateResult(config, input),
+            };
+        });
+    },
+    allowArithmeticExpressions: ['input-parameter'],
+});
+/**
+ * Calculates the appropriate interpolation value based on the specified method type in the config and input parameters.
+ */
+const calculateResult = (config, input) => {
+    const methodType = {
+        linear: getLinearInterpolation(config, input),
+        spline: getSplineInterpolation(config, input),
+        polynomial: getPolynomialInterpolation(config, input),
+    };
+    return methodType[config.method];
+};
+/**
+ * Calculates the interpolation when the method is linear.
+ */
+const getLinearInterpolation = (config, input) => {
+    const parameter = typeof config['input-parameter'] === 'number'
+        ? config['input-parameter']
+        : input[config['input-parameter']];
+    const xPoints = config.x;
+    const yPoints = config.y;
+    const result = xPoints.reduce((acc, xPoint, i) => {
+        if (parameter === xPoint) {
+            acc.baseCpu = xPoint;
+            acc.baseRate = yPoints[i];
+        }
+        else if (parameter > xPoint && parameter < xPoints[i + 1]) {
+            acc.baseCpu = xPoint;
+            acc.baseRate = yPoints[i];
+            acc.ratio = (yPoints[i + 1] - yPoints[i]) / (xPoints[i + 1] - xPoint);
+        }
+        return acc;
+    }, { baseRate: 0, baseCpu: 0, ratio: 0 });
+    return result.baseRate + (parameter - result.baseCpu) * result.ratio;
+};
+/**
+ * Calculates the interpolation when the method is spline.
+ */
+const getSplineInterpolation = (config, input) => {
+    const parameter = typeof config['input-parameter'] === 'number'
+        ? config['input-parameter']
+        : input[config['input-parameter']];
+    const xPoints = config.x;
+    const yPoints = config.y;
+    const spline = new typescript_cubic_spline_1.default(xPoints, yPoints);
+    return spline.at(parameter);
+};
+/**
+ * Calculates the interpolation when the method is polynomial.
+ */
+const getPolynomialInterpolation = (config, input) => {
+    const parameter = typeof config['input-parameter'] === 'number'
+        ? config['input-parameter']
+        : input[config['input-parameter']];
+    const xPoints = config.x;
+    const yPoints = config.y;
+    const result = xPoints.reduce((acc, x, i) => {
+        const term = yPoints[i] *
+            xPoints.reduce((prod, xPoint, j) => {
+                if (j !== i) {
+                    return (prod * (parameter - xPoint)) / (x - xPoint);
+                }
+                return prod;
+            }, 1);
+        return acc + term;
+    }, 0);
+    return result;
+};
+/**
+ * Sorts given point items in ascending order.
+ */
+const sortPoints = (items) => items.sort((a, b) => a - b);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/if-run/builtins/interpolation/index.ts"],"names":[],"mappings":";;;;;;AAAA,sFAA6C;AAC7C,6BAAsB;AAEtB,iDAAyE;AACzE,2DAAyD;AACzD,iDAA6C;AAE7C,kEAA0D;AAE1D,yCAAqC;AAErC,MAAM,EAAC,SAAS,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,cAAc,EAAC,GACzE,gBAAO,CAAC;AAEV,MAAM,EAAC,WAAW,EAAC,GAAG,cAAM,CAAC;AAEhB,QAAA,aAAa,GAAG,IAAA,0BAAa,EAAC;IACzC,gBAAgB,EAAE,CAAC,MAAoB,EAAE,EAAE;QACzC,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE;YAC3C,MAAM,IAAI,WAAW,CAAC,cAAc,CAAC,CAAC;SACvC;QAED,MAAM,MAAM,GAAG,OAAC;aACb,MAAM,CAAC;YACN,MAAM,EAAE,OAAC,CAAC,UAAU,CAAC,cAAM,CAAC;YAC5B,CAAC,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;YACtB,CAAC,EAAE,OAAC,CAAC,KAAK,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC;YACtB,iBAAiB,EAAE,OAAC,CAAC,MAAM,EAAE;YAC7B,kBAAkB,EAAE,OAAC,CAAC,MAAM,EAAE;SAC/B,CAAC;aACD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE;YACnE,OAAO,EAAE,SAAS;SACnB,CAAC;aACD,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;YACtD,OAAO,EAAE,sBAAsB;SAChC,CAAC,CAAC;QAEL,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,IAAI,cAAM,CAAC,MAAM,CAAC;QACrD,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,EAAC,MAAM,EAAE,aAAa,EAAC,EAAE,MAAM,EAAE;YACvE,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;YACvB,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;SACxB,CAAC,CAAC;QAEH,OAAO,IAAA,sBAAQ,EAAyB,MAAM,EAAE,aAAa,CAAC,CAAC;IACjE,CAAC;IACD,eAAe,EAAE,CACf,KAAmB,EACnB,MAAoB,EACpB,KAAyB,EACzB,EAAE;QACF,MAAM,cAAc,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAEjD,MAAM,MAAM,GAAG,OAAC;aACb,MAAM,CAAC;YACN,SAAS,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,OAAC,CAAC,IAAI,EAAE,CAAC;YAClC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE;YACpB,CAAC,cAAc,CAAC,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SACzD,CAAC;aACD,MAAM,CACL,IAAI,CAAC,EAAE,CACL,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,cAAc,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACxD,IAAI,CAAC,cAAc,CAAC,KAAK,KAAK,EAChC;YACE,OAAO,EAAE,gBAAgB;SAC1B,CACF,CAAC;QAEJ,OAAO,IAAA,sBAAQ,EAAyB,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IAChE,CAAC;IACD,cAAc,EAAE,KAAK,EAAE,MAAsB,EAAE,MAAoB,EAAE,EAAE;QACrE,MAAM,EACJ,iBAAiB,EAAE,cAAc,EACjC,kBAAkB,EAAE,eAAe,GACpC,GAAG,MAAM,CAAC;QAEX,OAAO,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YACxB,IAAI,KAAK,CAAC,cAAc,CAAC,KAAK,KAAK,EAAE;gBACnC,OAAO;oBACL,GAAG,KAAK;oBACR,CAAC,cAAc,CAAC,EAAE,CAAC;oBACnB,CAAC,eAAe,CAAC,EAAE,CAAC;iBACrB,CAAC;aACH;YAED,OAAO;gBACL,GAAG,KAAK;gBACR,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC;aAClD,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IACD,0BAA0B,EAAE,CAAC,iBAAiB,CAAC;CAChD,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,eAAe,GAAG,CAAC,MAAoB,EAAE,KAAmB,EAAE,EAAE;IACpE,MAAM,UAAU,GAA4B;QAC1C,MAAM,EAAE,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC;QAC7C,MAAM,EAAE,sBAAsB,CAAC,MAAM,EAAE,KAAK,CAAC;QAC7C,UAAU,EAAE,0BAA0B,CAAC,MAAM,EAAE,KAAK,CAAC;KACtD,CAAC;IAEF,OAAO,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;AACnC,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,sBAAsB,GAAG,CAAC,MAAoB,EAAE,KAAmB,EAAE,EAAE;IAC3E,MAAM,SAAS,GACb,OAAO,MAAM,CAAC,iBAAiB,CAAC,KAAK,QAAQ;QAC3C,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;QAC3B,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACvC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IACnC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAC3B,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE;QACjB,IAAI,SAAS,KAAK,MAAM,EAAE;YACxB,GAAG,CAAC,OAAO,GAAG,MAAM,CAAC;YACrB,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;SAC3B;aAAM,IAAI,SAAS,GAAG,MAAM,IAAI,SAAS,GAAG,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE;YAC3D,GAAG,CAAC,OAAO,GAAG,MAAM,CAAC;YACrB,GAAG,CAAC,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YAC1B,GAAG,CAAC,KAAK,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;SACvE;QAED,OAAO,GAAG,CAAC;IACb,CAAC,EACD,EAAC,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAC,CACpC,CAAC;IAEF,OAAO,MAAM,CAAC,QAAQ,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;AACvE,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,sBAAsB,GAAG,CAAC,MAAoB,EAAE,KAAmB,EAAE,EAAE;IAC3E,MAAM,SAAS,GACb,OAAO,MAAM,CAAC,iBAAiB,CAAC,KAAK,QAAQ;QAC3C,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;QAC3B,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACvC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IACnC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IACnC,MAAM,MAAM,GAAQ,IAAI,iCAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAEjD,OAAO,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,0BAA0B,GAAG,CACjC,MAAoB,EACpB,KAAmB,EACnB,EAAE;IACF,MAAM,SAAS,GACb,OAAO,MAAM,CAAC,iBAAiB,CAAC,KAAK,QAAQ;QAC3C,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC;QAC3B,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACvC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IACnC,MAAM,OAAO,GAAa,MAAM,CAAC,CAAC,CAAC;IAEnC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE;QAC1C,MAAM,IAAI,GACR,OAAO,CAAC,CAAC,CAAC;YACV,OAAO,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE;gBACjC,IAAI,CAAC,KAAK,CAAC,EAAE;oBACX,OAAO,CAAC,IAAI,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC;iBACrD;gBACD,OAAO,IAAI,CAAC;YACd,CAAC,EAAE,CAAC,CAAC,CAAC;QACR,OAAO,GAAG,GAAG,IAAI,CAAC;IACpB,CAAC,EAAE,CAAC,CAAC,CAAC;IAEN,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,GAAG,CAAC,KAAe,EAAE,EAAE,CACrC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAS,EAAE,CAAS,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC","sourcesContent":["import Spline from 'typescript-cubic-spline';\nimport {z} from 'zod';\n\nimport {PluginParams, ConfigParams, Method} from '@grnsft/if-core/types';\nimport {PluginFactory} from '@grnsft/if-core/interfaces';\nimport {ERRORS} from '@grnsft/if-core/utils';\n\nimport {validate} from '../../../common/util/validations';\n\nimport {STRINGS} from '../../config';\n\nconst {X_Y_EQUAL, ARRAY_LENGTH_NON_EMPTY, WITHIN_THE_RANGE, MISSING_CONFIG} =\n  STRINGS;\n\nconst {ConfigError} = ERRORS;\n\nexport const Interpolation = PluginFactory({\n  configValidation: (config: ConfigParams) => {\n    if (!config || !Object.keys(config)?.length) {\n      throw new ConfigError(MISSING_CONFIG);\n    }\n\n    const schema = z\n      .object({\n        method: z.nativeEnum(Method),\n        x: z.array(z.number()),\n        y: z.array(z.number()),\n        'input-parameter': z.string(),\n        'output-parameter': z.string(),\n      })\n      .refine(data => data.x && data.y && data.x.length === data.y.length, {\n        message: X_Y_EQUAL,\n      })\n      .refine(data => data.x.length > 1 && data.y.length > 1, {\n        message: ARRAY_LENGTH_NON_EMPTY,\n      });\n\n    const defaultMethod = config.method ?? Method.LINEAR;\n    const updatedConfig = Object.assign({}, {method: defaultMethod}, config, {\n      x: sortPoints(config.x),\n      y: sortPoints(config.y),\n    });\n\n    return validate<z.infer<typeof schema>>(schema, updatedConfig);\n  },\n  inputValidation: (\n    input: PluginParams,\n    config: ConfigParams,\n    index: number | undefined\n  ) => {\n    const inputParameter = config['input-parameter'];\n\n    const schema = z\n      .object({\n        timestamp: z.string().or(z.date()),\n        duration: z.number(),\n        [inputParameter]: z.number().gte(0).or(z.literal('off')),\n      })\n      .refine(\n        data =>\n          (data[inputParameter] >= config.x[0] &&\n            data[inputParameter] <= config.x[config.x.length - 1]) ||\n          data[inputParameter] === 'off',\n        {\n          message: WITHIN_THE_RANGE,\n        }\n      );\n\n    return validate<z.infer<typeof schema>>(schema, input, index);\n  },\n  implementation: async (inputs: PluginParams[], config: ConfigParams) => {\n    const {\n      'input-parameter': inputParameter,\n      'output-parameter': outputParameter,\n    } = config;\n\n    return inputs.map(input => {\n      if (input[inputParameter] === 'off') {\n        return {\n          ...input,\n          [inputParameter]: 0,\n          [outputParameter]: 0,\n        };\n      }\n\n      return {\n        ...input,\n        [outputParameter]: calculateResult(config, input),\n      };\n    });\n  },\n  allowArithmeticExpressions: ['input-parameter'],\n});\n\n/**\n * Calculates the appropriate interpolation value based on the specified method type in the config and input parameters.\n */\nconst calculateResult = (config: ConfigParams, input: PluginParams) => {\n  const methodType: {[key: string]: number} = {\n    linear: getLinearInterpolation(config, input),\n    spline: getSplineInterpolation(config, input),\n    polynomial: getPolynomialInterpolation(config, input),\n  };\n\n  return methodType[config.method];\n};\n\n/**\n * Calculates the interpolation when the method is linear.\n */\nconst getLinearInterpolation = (config: ConfigParams, input: PluginParams) => {\n  const parameter =\n    typeof config['input-parameter'] === 'number'\n      ? config['input-parameter']\n      : input[config['input-parameter']];\n  const xPoints: number[] = config.x;\n  const yPoints: number[] = config.y;\n\n  const result = xPoints.reduce(\n    (acc, xPoint, i) => {\n      if (parameter === xPoint) {\n        acc.baseCpu = xPoint;\n        acc.baseRate = yPoints[i];\n      } else if (parameter > xPoint && parameter < xPoints[i + 1]) {\n        acc.baseCpu = xPoint;\n        acc.baseRate = yPoints[i];\n        acc.ratio = (yPoints[i + 1] - yPoints[i]) / (xPoints[i + 1] - xPoint);\n      }\n\n      return acc;\n    },\n    {baseRate: 0, baseCpu: 0, ratio: 0}\n  );\n\n  return result.baseRate + (parameter - result.baseCpu) * result.ratio;\n};\n\n/**\n * Calculates the interpolation when the method is spline.\n */\nconst getSplineInterpolation = (config: ConfigParams, input: PluginParams) => {\n  const parameter =\n    typeof config['input-parameter'] === 'number'\n      ? config['input-parameter']\n      : input[config['input-parameter']];\n  const xPoints: number[] = config.x;\n  const yPoints: number[] = config.y;\n  const spline: any = new Spline(xPoints, yPoints);\n\n  return spline.at(parameter);\n};\n\n/**\n * Calculates the interpolation when the method is polynomial.\n */\nconst getPolynomialInterpolation = (\n  config: ConfigParams,\n  input: PluginParams\n) => {\n  const parameter =\n    typeof config['input-parameter'] === 'number'\n      ? config['input-parameter']\n      : input[config['input-parameter']];\n  const xPoints: number[] = config.x;\n  const yPoints: number[] = config.y;\n\n  const result = xPoints.reduce((acc, x, i) => {\n    const term =\n      yPoints[i] *\n      xPoints.reduce((prod, xPoint, j) => {\n        if (j !== i) {\n          return (prod * (parameter - xPoint)) / (x - xPoint);\n        }\n        return prod;\n      }, 1);\n    return acc + term;\n  }, 0);\n\n  return result;\n};\n\n/**\n * Sorts given point items in ascending order.\n */\nconst sortPoints = (items: number[]) =>\n  items.sort((a: number, b: number) => a - b);\n"]}

package/build/if-run/builtins/mock-observations/helpers/common-generator.d.ts

@@ -0,0 +1,3 @@
+import { ConfigParams } from '@grnsft/if-core/types';
+import { Generator } from '../interfaces';
+export declare const CommonGenerator: (config: ConfigParams) => Generator;

package/build/if-run/builtins/mock-observations/helpers/common-generator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonGenerator = void 0;
+const utils_1 = require("@grnsft/if-core/utils");
+const config_1 = require("../../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+const CommonGenerator = (config) => {
+    /**
+     * Generates next value by copying the validated config.
+     * Validates the provided config is not null or empty.
+     * Returns a copy of the validated config, otherwise throws an ConfigError.
+     */
+    const validateConfig = (config) => {
+        if (!config || Object.keys(config).length === 0) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        return structuredClone(config);
+    };
+    /**
+     * Generates next value by copying the validated config.
+     */
+    const next = () => validateConfig(config);
+    return {
+        next,
+    };
+};
+exports.CommonGenerator = CommonGenerator;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/mock-observations/helpers/rand-int-generator.d.ts

@@ -0,0 +1,3 @@
+import { ConfigParams } from '@grnsft/if-core/types';
+import { Generator } from '../interfaces';
+export declare const RandIntGenerator: (name: string, config: ConfigParams) => Generator;

package/build/if-run/builtins/mock-observations/helpers/rand-int-generator.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandIntGenerator = void 0;
+const utils_1 = require("@grnsft/if-core/utils");
+const config_1 = require("../../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG, MISSING_MIN_MAX, INVALID_MIN_MAX, INVALID_NAME } = config_1.STRINGS;
+const RandIntGenerator = (name, config) => {
+    const next = () => ({
+        [validatedName]: generateRandInt(getFieldToPopulate()),
+    });
+    const validateName = (name) => {
+        if (!name || name.trim() === '') {
+            throw new ConfigError(INVALID_NAME);
+        }
+        return name;
+    };
+    const validateConfig = (config) => {
+        if (!config || Object.keys(config).length === 0) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        if (!config.min || !config.max) {
+            throw new ConfigError(MISSING_MIN_MAX);
+        }
+        if (config.min >= config.max) {
+            throw new ConfigError(INVALID_MIN_MAX(validatedName));
+        }
+        return { min: config.min, max: config.max };
+    };
+    const validatedName = validateName(name);
+    const validatedConfig = validateConfig(config);
+    const getFieldToPopulate = () => ({
+        name: validatedName,
+        min: validatedConfig.min,
+        max: validatedConfig.max,
+    });
+    const generateRandInt = (randIntGenerator) => {
+        const randomNumber = Math.random();
+        const scaledNumber = randomNumber * (randIntGenerator.max - randIntGenerator.min) +
+            randIntGenerator.min;
+        return Math.trunc(scaledNumber);
+    };
+    return {
+        next,
+    };
+};
+exports.RandIntGenerator = RandIntGenerator;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZC1pbnQtZ2VuZXJhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2lmLXJ1bi9idWlsdGlucy9tb2NrLW9ic2VydmF0aW9ucy9oZWxwZXJzL3JhbmQtaW50LWdlbmVyYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpREFBNkM7QUFHN0MsNENBQXdDO0FBSXhDLE1BQU0sRUFBQyxXQUFXLEVBQUMsR0FBRyxjQUFNLENBQUM7QUFFN0IsTUFBTSxFQUFDLGNBQWMsRUFBRSxlQUFlLEVBQUUsZUFBZSxFQUFFLFlBQVksRUFBQyxHQUNwRSxnQkFBTyxDQUFDO0FBRUgsTUFBTSxnQkFBZ0IsR0FBRyxDQUM5QixJQUFZLEVBQ1osTUFBb0IsRUFDVCxFQUFFO0lBQ2IsTUFBTSxJQUFJLEdBQUcsR0FBRyxFQUFFLENBQUMsQ0FBQztRQUNsQixDQUFDLGFBQWEsQ0FBQyxFQUFFLGVBQWUsQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO0tBQ3ZELENBQUMsQ0FBQztJQUVILE1BQU0sWUFBWSxHQUFHLENBQUMsSUFBbUIsRUFBVSxFQUFFO1FBQ25ELElBQUksQ0FBQyxJQUFJLElBQUksSUFBSSxDQUFDLElBQUksRUFBRSxLQUFLLEVBQUUsRUFBRTtZQUMvQixNQUFNLElBQUksV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDO1NBQ3JDO1FBRUQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDLENBQUM7SUFFRixNQUFNLGNBQWMsR0FBRyxDQUFDLE1BQW9CLEVBQThCLEVBQUU7UUFDMUUsSUFBSSxDQUFDLE1BQU0sSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7WUFDL0MsTUFBTSxJQUFJLFdBQVcsQ0FBQyxjQUFjLENBQUMsQ0FBQztTQUN2QztRQUVELElBQUksQ0FBQyxNQUFNLENBQUMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRTtZQUM5QixNQUFNLElBQUksV0FBVyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1NBQ3hDO1FBRUQsSUFBSSxNQUFNLENBQUMsR0FBRyxJQUFJLE1BQU0sQ0FBQyxHQUFHLEVBQUU7WUFDNUIsTUFBTSxJQUFJLFdBQVcsQ0FBQyxlQUFlLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQztTQUN2RDtRQUVELE9BQU8sRUFBQyxHQUFHLEVBQUUsTUFBTSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsTUFBTSxDQUFDLEdBQUcsRUFBQyxDQUFDO0lBQzVDLENBQUMsQ0FBQztJQUVGLE1BQU0sYUFBYSxHQUFHLFlBQVksQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUN6QyxNQUFNLGVBQWUsR0FBRyxjQUFjLENBQUMsTUFBTSxDQUFDLENBQUM7SUFFL0MsTUFBTSxrQkFBa0IsR0FBRyxHQUFHLEVBQUUsQ0FBQyxDQUFDO1FBQ2hDLElBQUksRUFBRSxhQUFhO1FBQ25CLEdBQUcsRUFBRSxlQUFlLENBQUMsR0FBRztRQUN4QixHQUFHLEVBQUUsZUFBZSxDQUFDLEdBQUc7S0FDekIsQ0FBQyxDQUFDO0lBRUgsTUFBTSxlQUFlLEdBQUcsQ0FDdEIsZ0JBQXdDLEVBQ2hDLEVBQUU7UUFDVixNQUFNLFlBQVksR0FBRyxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDbkMsTUFBTSxZQUFZLEdBQ2hCLFlBQVksR0FBRyxDQUFDLGdCQUFnQixDQUFDLEdBQUcsR0FBRyxnQkFBZ0IsQ0FBQyxHQUFHLENBQUM7WUFDNUQsZ0JBQWdCLENBQUMsR0FBRyxDQUFDO1FBRXZCLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUNsQyxDQUFDLENBQUM7SUFFRixPQUFPO1FBQ0wsSUFBSTtLQUNMLENBQUM7QUFDSixDQUFDLENBQUM7QUF2RFcsUUFBQSxnQkFBZ0Isb0JBdUQzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RVJST1JTfSBmcm9tICdAZ3Juc2Z0L2lmLWNvcmUvdXRpbHMnO1xuaW1wb3J0IHtSYW5kSW50R2VuZXJhdG9yUGFyYW1zLCBDb25maWdQYXJhbXN9IGZyb20gJ0Bncm5zZnQvaWYtY29yZS90eXBlcyc7XG5cbmltcG9ydCB7U1RSSU5HU30gZnJvbSAnLi4vLi4vLi4vY29uZmlnJztcblxuaW1wb3J0IHtHZW5lcmF0b3J9IGZyb20gJy4uL2ludGVyZmFjZXMnO1xuXG5jb25zdCB7Q29uZmlnRXJyb3J9ID0gRVJST1JTO1xuXG5jb25zdCB7TUlTU0lOR19DT05GSUcsIE1JU1NJTkdfTUlOX01BWCwgSU5WQUxJRF9NSU5fTUFYLCBJTlZBTElEX05BTUV9ID1cbiAgU1RSSU5HUztcblxuZXhwb3J0IGNvbnN0IFJhbmRJbnRHZW5lcmF0b3IgPSAoXG4gIG5hbWU6IHN0cmluZyxcbiAgY29uZmlnOiBDb25maWdQYXJhbXNcbik6IEdlbmVyYXRvciA9PiB7XG4gIGNvbnN0IG5leHQgPSAoKSA9PiAoe1xuICAgIFt2YWxpZGF0ZWROYW1lXTogZ2VuZXJhdGVSYW5kSW50KGdldEZpZWxkVG9Qb3B1bGF0ZSgpKSxcbiAgfSk7XG5cbiAgY29uc3QgdmFsaWRhdGVOYW1lID0gKG5hbWU6IHN0cmluZyB8IG51bGwpOiBzdHJpbmcgPT4ge1xuICAgIGlmICghbmFtZSB8fCBuYW1lLnRyaW0oKSA9PT0gJycpIHtcbiAgICAgIHRocm93IG5ldyBDb25maWdFcnJvcihJTlZBTElEX05BTUUpO1xuICAgIH1cblxuICAgIHJldHVybiBuYW1lO1xuICB9O1xuXG4gIGNvbnN0IHZhbGlkYXRlQ29uZmlnID0gKGNvbmZpZzogQ29uZmlnUGFyYW1zKToge21pbjogbnVtYmVyOyBtYXg6IG51bWJlcn0gPT4ge1xuICAgIGlmICghY29uZmlnIHx8IE9iamVjdC5rZXlzKGNvbmZpZykubGVuZ3RoID09PSAwKSB7XG4gICAgICB0aHJvdyBuZXcgQ29uZmlnRXJyb3IoTUlTU0lOR19DT05GSUcpO1xuICAgIH1cblxuICAgIGlmICghY29uZmlnLm1pbiB8fCAhY29uZmlnLm1heCkge1xuICAgICAgdGhyb3cgbmV3IENvbmZpZ0Vycm9yKE1JU1NJTkdfTUlOX01BWCk7XG4gICAgfVxuXG4gICAgaWYgKGNvbmZpZy5taW4gPj0gY29uZmlnLm1heCkge1xuICAgICAgdGhyb3cgbmV3IENvbmZpZ0Vycm9yKElOVkFMSURfTUlOX01BWCh2YWxpZGF0ZWROYW1lKSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHttaW46IGNvbmZpZy5taW4sIG1heDogY29uZmlnLm1heH07XG4gIH07XG5cbiAgY29uc3QgdmFsaWRhdGVkTmFtZSA9IHZhbGlkYXRlTmFtZShuYW1lKTtcbiAgY29uc3QgdmFsaWRhdGVkQ29uZmlnID0gdmFsaWRhdGVDb25maWcoY29uZmlnKTtcblxuICBjb25zdCBnZXRGaWVsZFRvUG9wdWxhdGUgPSAoKSA9PiAoe1xuICAgIG5hbWU6IHZhbGlkYXRlZE5hbWUsXG4gICAgbWluOiB2YWxpZGF0ZWRDb25maWcubWluLFxuICAgIG1heDogdmFsaWRhdGVkQ29uZmlnLm1heCxcbiAgfSk7XG5cbiAgY29uc3QgZ2VuZXJhdGVSYW5kSW50ID0gKFxuICAgIHJhbmRJbnRHZW5lcmF0b3I6IFJhbmRJbnRHZW5lcmF0b3JQYXJhbXNcbiAgKTogbnVtYmVyID0+IHtcbiAgICBjb25zdCByYW5kb21OdW1iZXIgPSBNYXRoLnJhbmRvbSgpO1xuICAgIGNvbnN0IHNjYWxlZE51bWJlciA9XG4gICAgICByYW5kb21OdW1iZXIgKiAocmFuZEludEdlbmVyYXRvci5tYXggLSByYW5kSW50R2VuZXJhdG9yLm1pbikgK1xuICAgICAgcmFuZEludEdlbmVyYXRvci5taW47XG5cbiAgICByZXR1cm4gTWF0aC50cnVuYyhzY2FsZWROdW1iZXIpO1xuICB9O1xuXG4gIHJldHVybiB7XG4gICAgbmV4dCxcbiAgfTtcbn07XG4iXX0=

package/build/if-run/builtins/mock-observations/index.d.ts

@@ -0,0 +1,16 @@
+import { PluginParams, ConfigParams } from '@grnsft/if-core/types';
+export declare const MockObservations: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/mock-observations/index.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockObservations = void 0;
+const luxon_1 = require("luxon");
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const common_generator_1 = require("./helpers/common-generator");
+const rand_int_generator_1 = require("./helpers/rand-int-generator");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+exports.MockObservations = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const schema = zod_1.z.object({
+            'timestamp-from': zod_1.z.string(),
+            'timestamp-to': zod_1.z.string(),
+            duration: zod_1.z.number().gt(0),
+            components: zod_1.z.array(zod_1.z.record(zod_1.z.string())),
+            generators: zod_1.z.object({
+                common: zod_1.z.record(zod_1.z.string().or(zod_1.z.number())),
+                randint: zod_1.z.record(zod_1.z.object({ min: zod_1.z.number(), max: zod_1.z.number() })),
+            }),
+        });
+        return (0, validations_1.validate)(schema, config);
+    },
+    implementation: async (inputs, config) => {
+        const { duration, timeBuckets, components, generators } = generateParamsFromConfig(config);
+        const generatorToHistory = new Map();
+        generators.forEach(generator => {
+            generatorToHistory.set(generator, []);
+        });
+        const defaults = inputs && inputs[0];
+        return Object.entries(components).reduce((acc, item) => {
+            const component = item[1];
+            timeBuckets.forEach(timeBucket => {
+                const observation = createObservation({ duration, component, timeBucket, generators }, generatorToHistory);
+                acc.push(Object.assign({}, defaults, observation));
+            });
+            return acc;
+        }, []);
+    },
+});
+/**
+ * Configures the MockObservations Plugin for IF
+ */
+const generateParamsFromConfig = (config) => {
+    const { 'timestamp-from': timestampFrom, 'timestamp-to': timestampTo, duration, generators, components, } = config;
+    const convertedTimestampFrom = luxon_1.DateTime.fromISO(timestampFrom, {
+        zone: 'UTC',
+    });
+    const convertedTimestampTo = luxon_1.DateTime.fromISO(timestampTo, { zone: 'UTC' });
+    return {
+        duration,
+        timeBuckets: createTimeBuckets(convertedTimestampFrom, convertedTimestampTo, duration),
+        generators: createGenerators(generators),
+        components,
+    };
+};
+/*
+ * Creates time buckets based on start time, end time and duration of each bucket.
+ */
+const createTimeBuckets = (timestampFrom, timestampTo, duration, timeBuckets = []) => {
+    if (timestampFrom < timestampTo ||
+        timestampFrom.plus(luxon_1.Duration.fromObject({ seconds: duration })) < timestampTo) {
+        return createTimeBuckets(timestampFrom.plus(luxon_1.Duration.fromObject({ seconds: duration })), timestampTo, duration, [...timeBuckets, timestampFrom]);
+    }
+    return timeBuckets;
+};
+/*
+ * Creates generators based on a given config
+ */
+const createGenerators = (generatorsConfig) => {
+    const createCommonGenerator = (config) => [
+        (0, common_generator_1.CommonGenerator)(config),
+    ];
+    const createRandIntGenerators = (config) => Object.entries(config).map(([fieldToPopulate, value]) => (0, rand_int_generator_1.RandIntGenerator)(fieldToPopulate, value));
+    return Object.entries(generatorsConfig).flatMap(([key, value]) => key === 'randint'
+        ? createRandIntGenerators(value).flat()
+        : createCommonGenerator(value));
+};
+/*
+ * Creates time buckets based on start time, end time and duration of each bucket.
+ */
+const createObservation = (observationParams, generatorToHistory) => {
+    const { duration, component, timeBucket, generators } = observationParams;
+    const timestamp = timeBucket.toISO();
+    const generateObservation = (generator) => {
+        const history = generatorToHistory.get(generator) || [];
+        const generated = generator.next(history);
+        generatorToHistory.set(generator, [...history, generated.value]);
+        return generated;
+    };
+    const generateObservations = (gen) => generateObservation(gen);
+    const generatedValues = generators.map(generateObservations);
+    const initialObservation = {
+        timestamp,
+        duration,
+        ...component,
+    };
+    const generatedObservation = generatedValues.reduce((observation, generated) => Object.assign(observation, generated), initialObservation);
+    return generatedObservation;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/if-run/builtins/mock-observations/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {DateTime, Duration} from 'luxon';\nimport {z} from 'zod';\n\nimport {PluginFactory} from '@grnsft/if-core/interfaces';\nimport {\n  PluginParams,\n  ConfigParams,\n  ObservationParams,\n} from '@grnsft/if-core/types';\nimport {ERRORS} from '@grnsft/if-core/utils';\n\nimport {validate} from '../../../common/util/validations';\n\nimport {STRINGS} from '../../config';\n\nimport {CommonGenerator} from './helpers/common-generator';\nimport {RandIntGenerator} from './helpers/rand-int-generator';\n\nimport {Generator} from './interfaces/index';\n\nconst {ConfigError} = ERRORS;\nconst {MISSING_CONFIG} = STRINGS;\n\nexport const MockObservations = PluginFactory({\n  configValidation: (config: ConfigParams) => {\n    if (!config || !Object.keys(config)?.length) {\n      throw new ConfigError(MISSING_CONFIG);\n    }\n\n    const schema = z.object({\n      'timestamp-from': z.string(),\n      'timestamp-to': z.string(),\n      duration: z.number().gt(0),\n      components: z.array(z.record(z.string())),\n      generators: z.object({\n        common: z.record(z.string().or(z.number())),\n        randint: z.record(z.object({min: z.number(), max: z.number()})),\n      }),\n    });\n\n    return validate<z.infer<typeof schema>>(schema, config);\n  },\n  implementation: async (inputs: PluginParams[], config: ConfigParams) => {\n    const {duration, timeBuckets, components, generators} =\n      generateParamsFromConfig(config);\n    const generatorToHistory = new Map<Generator, number[]>();\n\n    generators.forEach(generator => {\n      generatorToHistory.set(generator, []);\n    });\n\n    const defaults = inputs && inputs[0];\n\n    return Object.entries(components).reduce((acc: PluginParams[], item) => {\n      const component: any = item[1];\n      timeBuckets.forEach(timeBucket => {\n        const observation = createObservation(\n          {duration, component, timeBucket, generators},\n          generatorToHistory\n        );\n\n        acc.push(Object.assign({}, defaults, observation));\n      });\n\n      return acc;\n    }, []);\n  },\n});\n\n/**\n * Configures the MockObservations Plugin for IF\n */\nconst generateParamsFromConfig = (config: ConfigParams) => {\n  const {\n    'timestamp-from': timestampFrom,\n    'timestamp-to': timestampTo,\n    duration,\n    generators,\n    components,\n  } = config;\n\n  const convertedTimestampFrom = DateTime.fromISO(timestampFrom, {\n    zone: 'UTC',\n  });\n  const convertedTimestampTo = DateTime.fromISO(timestampTo, {zone: 'UTC'});\n\n  return {\n    duration,\n    timeBuckets: createTimeBuckets(\n      convertedTimestampFrom,\n      convertedTimestampTo,\n      duration\n    ),\n    generators: createGenerators(generators),\n    components,\n  };\n};\n\n/*\n * Creates time buckets based on start time, end time and duration of each bucket.\n */\nconst createTimeBuckets = (\n  timestampFrom: DateTime,\n  timestampTo: DateTime,\n  duration: number,\n  timeBuckets: DateTime[] = []\n): DateTime[] => {\n  if (\n    timestampFrom < timestampTo ||\n    timestampFrom.plus(Duration.fromObject({seconds: duration})) < timestampTo\n  ) {\n    return createTimeBuckets(\n      timestampFrom.plus(Duration.fromObject({seconds: duration})),\n      timestampTo,\n      duration,\n      [...timeBuckets, timestampFrom]\n    );\n  }\n  return timeBuckets;\n};\n\n/*\n * Creates generators based on a given config\n */\nconst createGenerators = (generatorsConfig: object): Generator[] => {\n  const createCommonGenerator = (config: any): Generator[] => [\n    CommonGenerator(config),\n  ];\n\n  const createRandIntGenerators = (config: any): Generator[] =>\n    Object.entries(config).map(([fieldToPopulate, value]) =>\n      RandIntGenerator(fieldToPopulate, value as Record<string, any>)\n    );\n\n  return Object.entries(generatorsConfig).flatMap(([key, value]) =>\n    key === 'randint'\n      ? createRandIntGenerators(value).flat()\n      : createCommonGenerator(value)\n  );\n};\n\n/*\n * Creates time buckets based on start time, end time and duration of each bucket.\n */\nconst createObservation = (\n  observationParams: ObservationParams,\n  generatorToHistory: Map<Generator, number[]>\n): PluginParams => {\n  const {duration, component, timeBucket, generators} = observationParams;\n  const timestamp = timeBucket.toISO();\n\n  const generateObservation = (generator: Generator) => {\n    const history = generatorToHistory.get(generator) || [];\n    const generated: Record<string, any> = generator.next(history);\n\n    generatorToHistory.set(generator, [...history, generated.value]);\n\n    return generated;\n  };\n\n  const generateObservations = (gen: Generator) => generateObservation(gen);\n  const generatedValues = generators.map(generateObservations);\n  const initialObservation: PluginParams = {\n    timestamp,\n    duration,\n    ...component,\n  };\n  const generatedObservation = generatedValues.reduce(\n    (observation, generated) => Object.assign(observation, generated),\n    initialObservation\n  );\n\n  return generatedObservation as PluginParams;\n};\n"]}

package/build/if-run/builtins/mock-observations/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export type Generator = {
+    /**
+     * generate the next value, optionally based on historical values
+     */
+    next: (historical: Object[] | undefined) => Object;
+};

package/build/if-run/builtins/mock-observations/interfaces/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvaWYtcnVuL2J1aWx0aW5zL21vY2stb2JzZXJ2YXRpb25zL2ludGVyZmFjZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEdlbmVyYXRvciA9IHtcbiAgLyoqXG4gICAqIGdlbmVyYXRlIHRoZSBuZXh0IHZhbHVlLCBvcHRpb25hbGx5IGJhc2VkIG9uIGhpc3RvcmljYWwgdmFsdWVzXG4gICAqL1xuICBuZXh0OiAoaGlzdG9yaWNhbDogT2JqZWN0W10gfCB1bmRlZmluZWQpID0+IE9iamVjdDtcbn07XG4iXX0=

package/build/if-run/builtins/multiply/index.d.ts

@@ -0,0 +1,16 @@
+import { PluginParams, ConfigParams } from '@grnsft/if-core/types';
+export declare const Multiply: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/multiply/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Multiply = void 0;
+const zod_1 = require("zod");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { ConfigError } = utils_1.ERRORS;
+const { MISSING_CONFIG } = config_1.STRINGS;
+exports.Multiply = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const configSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(configSchema, config);
+    },
+    inputValidation: (input, config) => {
+        const inputParameters = config['input-parameters'];
+        const inputData = inputParameters.reduce((acc, param) => {
+            acc[param] = input[param];
+            return acc;
+        }, {});
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        return (0, validations_1.validate)(validationSchema, inputData);
+    },
+    implementation: async (inputs, config) => {
+        const { 'input-parameters': inputParameters, 'output-parameter': outputParameter, } = config;
+        return inputs.map(input => {
+            const calculatedResult = calculateProduct(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculatedResult,
+            };
+        });
+    },
+    allowArithmeticExpressions: [],
+});
+/**
+ * Calculates the product of the components.
+ */
+const calculateProduct = (input, inputParameters) => inputParameters.reduce((accumulator, metricToMultiply) => accumulator * input[metricToMultiply], 1);
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/regex/index.d.ts

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const Regex: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};

package/build/if-run/builtins/regex/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Regex = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const interfaces_1 = require("@grnsft/if-core/interfaces");
+const { MissingInputDataError, ConfigError, RegexMismatchError } = utils_1.ERRORS;
+const { MISSING_CONFIG, MISSING_INPUT_DATA, REGEX_MISMATCH } = config_1.STRINGS;
+exports.Regex = (0, interfaces_1.PluginFactory)({
+    configValidation: (config) => {
+        if (!config || !Object.keys(config)?.length) {
+            throw new ConfigError(MISSING_CONFIG);
+        }
+        const schema = zod_1.z.object({
+            parameter: zod_1.z.string().min(1),
+            match: zod_1.z.string().min(1),
+            output: zod_1.z.string(),
+        });
+        return (0, validations_1.validate)(schema, config);
+    },
+    inputValidation: (input, config) => {
+        const parameter = config['parameter'];
+        if (!input[parameter]) {
+            throw new MissingInputDataError(MISSING_INPUT_DATA(parameter));
+        }
+        return input;
+    },
+    implementation: async (inputs, config) => {
+        const { parameter: parameter, match, output } = config;
+        return inputs.map(input => ({
+            ...input,
+            [output]: extractMatching(input, parameter, match),
+        }));
+    },
+});
+/**
+ * Extracts a substring from the given input parameter that matches the provided regular expression pattern.
+ */
+const extractMatching = (input, parameter, match) => {
+    if (!match.startsWith('/')) {
+        match = '/' + match;
+    }
+    if (!match.endsWith('/g') && !match.endsWith('/')) {
+        match += '/';
+    }
+    const regex = eval(match);
+    const matchedItems = input[parameter].match(regex);
+    if (!matchedItems || matchedItems.length === 0) {
+        throw new RegexMismatchError(REGEX_MISMATCH(input[parameter], match));
+    }
+    return matchedItems.join(' ');
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/sci/index.d.ts

@@ -0,0 +1,16 @@
+import { ConfigParams, PluginParams } from '@grnsft/if-core/types';
+export declare const Sci: (config: ConfigParams | undefined, parametersMetadata: import("@grnsft/if-core/types").PluginParametersMetadata, mapping: import("@grnsft/if-core/types").MappingParams) => {
+    metadata: {
+        inputs: {
+            [x: string]: {
+                description: string;
+                unit: string;
+                'aggregation-method': import("@grnsft/if-core/types").AggregationOptions;
+            };
+        };
+        outputs: import("@grnsft/if-core/types").ParameterMetadata;
+    };
+    execute: (inputs: PluginParams[]) => Promise<{
+        [x: string]: any;
+    }[]>;
+};