industrial-model 0.11.2 → 0.12.0

package/dist/calculator/index.js

@@ -0,0 +1,879 @@
+// src/cognite/adapter.ts
+function createCogniteAdapter(client) {
+  return new CogniteSdkAdapter(client);
+}
+var CogniteSdkAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async retrieveDataModels(ids, options) {
+    const response = await this.client.dataModels.retrieve(ids, options);
+    return {
+      items: response.items.map((item) => ({
+        createdTime: item.createdTime,
+        views: item.views ?? []
+      }))
+    };
+  }
+  async retrieveViews(ids) {
+    const cleanIds = ids.map(({ space, externalId, version }) => ({ space, externalId, version }));
+    const response = await this.client.views.retrieve(cleanIds);
+    return { items: response.items };
+  }
+  async queryInstances(request) {
+    const response = await this.client.instances.query(
+      request
+    );
+    return {
+      items: response.items,
+      nextCursor: response.nextCursor
+    };
+  }
+  async searchInstances(request) {
+    const search = this.client.instances.search;
+    const response = await search(request);
+    return {
+      items: response.items
+    };
+  }
+  async aggregateInstances(request) {
+    const response = await this.client.instances.aggregate(
+      request
+    );
+    return {
+      items: response.items
+    };
+  }
+  async applyInstances(request) {
+    const apply = this.client.instances.apply;
+    const response = await apply(request);
+    return {
+      items: response.items
+    };
+  }
+  async retrieveDatapoints(options) {
+    const { items, ...rest } = options;
+    const sdkItems = items.map(({ space, externalId, ...itemRest }) => ({
+      ...itemRest,
+      instanceId: { space, externalId }
+    }));
+    const response = await this.client.datapoints.retrieve({
+      ...rest,
+      items: sdkItems
+    });
+    return { items: response.map(mapDatapointResult) };
+  }
+  async retrieveLatestDatapoints(items, options) {
+    const sdkItems = items.map(({ space, externalId, before }) => ({
+      instanceId: { space, externalId },
+      ...before !== void 0 ? { before } : {}
+    }));
+    const response = await this.client.datapoints.retrieveLatest(
+      sdkItems,
+      options
+    );
+    return { items: response.map(mapDatapointResult) };
+  }
+  async insertDatapoints(items) {
+    const sdkItems = items.map(({ space, externalId, datapoints }) => ({
+      instanceId: { space, externalId },
+      datapoints
+    }));
+    await this.client.datapoints.insert(
+      sdkItems
+    );
+  }
+  async deleteDatapoints(items) {
+    const sdkItems = items.map(({ space, externalId, inclusiveBegin, exclusiveEnd }) => ({
+      instanceId: { space, externalId },
+      inclusiveBegin,
+      ...exclusiveEnd !== void 0 ? { exclusiveEnd } : {}
+    }));
+    await this.client.datapoints.delete(
+      sdkItems
+    );
+  }
+  async uploadFile(fileInfo, content) {
+    const { instanceId, ...rest } = fileInfo;
+    const response = await this.client.files.upload(
+      { ...rest, instanceId },
+      content,
+      false,
+      content !== void 0
+    );
+    return mapFileResult(response);
+  }
+  async getFileDownloadUrls(ids) {
+    const response = await this.client.files.getDownloadUrls(
+      ids
+    );
+    return response.map((item) => ({
+      ...item.instanceId !== void 0 ? { instanceId: item.instanceId } : {},
+      downloadUrl: item.downloadUrl
+    }));
+  }
+};
+function mapFileResult(item) {
+  return {
+    ...item.instanceId !== void 0 ? { instanceId: item.instanceId } : {},
+    name: item.name,
+    uploaded: item.uploaded,
+    createdTime: item.createdTime,
+    lastUpdatedTime: item.lastUpdatedTime,
+    ...item.uploadedTime !== void 0 ? { uploadedTime: item.uploadedTime } : {},
+    ...item.mimeType !== void 0 ? { mimeType: item.mimeType } : {},
+    ...item.directory !== void 0 ? { directory: item.directory } : {},
+    ...item.source !== void 0 ? { source: item.source } : {},
+    ...item.uploadUrl !== void 0 ? { uploadUrl: item.uploadUrl } : {}
+  };
+}
+function mapDatapointResult(item) {
+  return {
+    ...item.instanceId?.space !== void 0 ? { space: item.instanceId.space } : {},
+    ...item.instanceId?.externalId !== void 0 ? { externalId: item.instanceId.externalId } : {},
+    isString: item.isString ?? false,
+    ...item.unit !== void 0 ? { unit: item.unit } : {},
+    datapoints: item.datapoints ?? [],
+    ...item.nextCursor !== void 0 ? { nextCursor: item.nextCursor } : {}
+  };
+}
+
+// src/calculator/datapoints-retrieval.ts
+var DatapointsRetriever = class {
+  constructor(cognite) {
+    this.cognite = cognite;
+  }
+  cognite;
+  async retrieveDatapoints(parameters, start, end) {
+    const { requests, indexMapping } = this.buildRequests(parameters);
+    if (requests.length === 0) {
+      return parameters.map(() => []);
+    }
+    const options = { items: requests, start, end };
+    const raw = await this.cognite.retrieveDatapoints(options);
+    return parameters.map((parameter, index) => {
+      const requestIndex = indexMapping[index];
+      const item = raw.items[requestIndex];
+      if (item === void 0) {
+        throw new Error(`missing datapoints response for parameter '${parameter.alias}'`);
+      }
+      return parseDatapoints(item, parameter);
+    });
+  }
+  buildRequests(parameters) {
+    const rawRequestIndex = /* @__PURE__ */ new Map();
+    const aggregateRequestIndex = /* @__PURE__ */ new Map();
+    const requests = [];
+    const indexMapping = new Array(parameters.length);
+    parameters.forEach((parameter, index) => {
+      const { space, externalId } = parameter.timeSeries;
+      const tsKey = `${space}:${externalId}`;
+      if (parameter.aggregateType === void 0) {
+        let requestIndex2 = rawRequestIndex.get(tsKey);
+        if (requestIndex2 === void 0) {
+          requestIndex2 = requests.length;
+          rawRequestIndex.set(tsKey, requestIndex2);
+          requests.push({ space, externalId });
+        }
+        indexMapping[index] = requestIndex2;
+        return;
+      }
+      if (parameter.granularity === void 0) {
+        throw new Error(
+          `Missing granularity for '${parameter.alias}' with aggregate '${parameter.aggregateType}'`
+        );
+      }
+      const aggregateKey = `${tsKey}|${parameter.granularity}`;
+      let requestIndex = aggregateRequestIndex.get(aggregateKey);
+      if (requestIndex === void 0) {
+        requestIndex = requests.length;
+        aggregateRequestIndex.set(aggregateKey, requestIndex);
+        requests.push({
+          space,
+          externalId,
+          aggregates: [parameter.aggregateType],
+          granularity: parameter.granularity
+        });
+      } else {
+        const entry = requests[requestIndex];
+        const aggregates = entry.aggregates;
+        if (!aggregates.includes(parameter.aggregateType)) {
+          aggregates.push(parameter.aggregateType);
+        }
+      }
+      indexMapping[index] = requestIndex;
+    });
+    return { requests, indexMapping };
+  }
+};
+function parseDatapoints(item, parameter) {
+  if (item.isString) {
+    throw new Error("expected numeric datapoints, got string");
+  }
+  const result = [];
+  for (const datapoint of item.datapoints) {
+    const value = readValue(datapoint, parameter.aggregateType);
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    result.push({ timestamp: datapoint.timestamp, value });
+  }
+  return result;
+}
+function readValue(datapoint, aggregateType) {
+  if (aggregateType === void 0) {
+    return datapoint.value;
+  }
+  return datapoint[aggregateType];
+}
+
+// src/calculator/formula-expression/ast.ts
+function isConditionalNode(node) {
+  return node.kind === "compare" || node.kind === "boolop" || node.kind === "ifexp";
+}
+
+// src/calculator/formula-expression/exceptions.ts
+var FormulaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FormulaError";
+  }
+};
+var InvalidFormulaError = class extends FormulaError {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidFormulaError";
+  }
+};
+var MissingParameterError = class extends FormulaError {
+  missing;
+  constructor(missing) {
+    super(`missing formula parameter(s): ${missing.join(", ")}`);
+    this.name = "MissingParameterError";
+    this.missing = [...missing];
+  }
+};
+var ParameterError = class extends FormulaError {
+  constructor(message) {
+    super(message);
+    this.name = "ParameterError";
+  }
+};
+var ParameterLengthError = class extends ParameterError {
+  lengths;
+  constructor(lengths) {
+    const detail = Object.entries(lengths).map(([name, length]) => `'${name}' has ${length}`).join(", ");
+    super(`parameter length mismatch: ${detail}`);
+    this.name = "ParameterLengthError";
+    this.lengths = { ...lengths };
+  }
+};
+var ArithmeticError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ArithmeticError";
+  }
+};
+var ZeroDivisionError = class extends ArithmeticError {
+  constructor(message) {
+    super(message);
+    this.name = "ZeroDivisionError";
+  }
+};
+var OverflowError = class extends ArithmeticError {
+  constructor(message) {
+    super(message);
+    this.name = "OverflowError";
+  }
+};
+
+// src/calculator/formula-expression/compiler.ts
+var PLACEHOLDER_RE = /\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+var UNRESOLVED_BRACE_RE = /[{}]/;
+var SAFE_NAME_PREFIX = "__formula_expression_param_";
+var CACHE_MAX_SIZE = 1024;
+var cache = /* @__PURE__ */ new Map();
+function compileFormula(formula) {
+  const normalized = normalizeFormulaText(formula);
+  const cached = cache.get(normalized);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const compiled = compileNormalized(normalized);
+  if (cache.size >= CACHE_MAX_SIZE) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== void 0) {
+      cache.delete(oldest);
+    }
+  }
+  cache.set(normalized, compiled);
+  return compiled;
+}
+function clearCache() {
+  cache.clear();
+}
+function normalizeFormulaText(formula) {
+  if (typeof formula !== "string") {
+    throw new TypeError("formula must be a string");
+  }
+  const trimmed = formula.trim();
+  if (trimmed === "") {
+    return "";
+  }
+  return trimmed.split(/\s+/).join(" ");
+}
+function compileNormalized(raw) {
+  if (raw === "") {
+    throw new InvalidFormulaError("formula must not be empty");
+  }
+  const variables = [];
+  const nameMap = /* @__PURE__ */ new Map();
+  const expression = replacePlaceholders(raw, variables, nameMap);
+  if (variables.length === 0) {
+    throw new InvalidFormulaError("formula must reference at least one parameter");
+  }
+  if (UNRESOLVED_BRACE_RE.test(expression)) {
+    throw new InvalidFormulaError("formula contains invalid placeholder syntax");
+  }
+  const tree = parse(expression);
+  validateTree(tree, new Set(nameMap.values()));
+  const hasConditional = treeHasConditional(tree);
+  return { raw, expression, tree, variables, nameMap, hasConditional };
+}
+function replacePlaceholders(formula, variables, nameMap) {
+  return formula.replace(PLACEHOLDER_RE, (_match, name) => {
+    let safe = nameMap.get(name);
+    if (safe === void 0) {
+      safe = `${SAFE_NAME_PREFIX}${nameMap.size}`;
+      nameMap.set(name, safe);
+      variables.push(name);
+    }
+    return safe;
+  });
+}
+function validateTree(tree, allowedNames) {
+  walk(tree, (node) => {
+    if (node.kind === "name" && !allowedNames.has(node.id)) {
+      throw new InvalidFormulaError(`unknown formula identifier: ${node.id}`);
+    }
+  });
+}
+function treeHasConditional(tree) {
+  let found = false;
+  walk(tree, (node) => {
+    if (isConditionalNode(node)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function walk(node, visit) {
+  visit(node);
+  switch (node.kind) {
+    case "binop":
+      walk(node.left, visit);
+      walk(node.right, visit);
+      break;
+    case "unaryop":
+      walk(node.operand, visit);
+      break;
+    case "compare":
+      walk(node.left, visit);
+      for (const comparator of node.comparators) {
+        walk(comparator, visit);
+      }
+      break;
+    case "boolop":
+      for (const value of node.values) {
+        walk(value, visit);
+      }
+      break;
+    case "ifexp":
+      walk(node.test, visit);
+      walk(node.body, visit);
+      walk(node.orelse, visit);
+      break;
+  }
+}
+var NUMBER_RE = /(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/y;
+var IDENT_RE = /[A-Za-z_][A-Za-z0-9_]*/y;
+var TWO_CHAR_OPS = /* @__PURE__ */ new Set(["**", "==", "!=", "<=", ">="]);
+var ONE_CHAR_OPS = /* @__PURE__ */ new Set(["+", "-", "*", "/", "%", "(", ")", "<", ">"]);
+function tokenize(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === " ") {
+      index += 1;
+      continue;
+    }
+    if (isDigit(char) || char === "." && isDigit(expression[index + 1])) {
+      NUMBER_RE.lastIndex = index;
+      const match = NUMBER_RE.exec(expression);
+      if (match === null) {
+        throw new InvalidFormulaError("invalid formula syntax: malformed number");
+      }
+      tokens.push({ type: "number", value: Number(match[0]) });
+      index = NUMBER_RE.lastIndex;
+      continue;
+    }
+    if (isIdentStart(char)) {
+      IDENT_RE.lastIndex = index;
+      const match = IDENT_RE.exec(expression);
+      const value = match[0];
+      tokens.push({ type: "name", value });
+      index = IDENT_RE.lastIndex;
+      continue;
+    }
+    const twoChar = expression.slice(index, index + 2);
+    if (TWO_CHAR_OPS.has(twoChar)) {
+      tokens.push({ type: "op", value: twoChar });
+      index += 2;
+      continue;
+    }
+    if (char !== void 0 && ONE_CHAR_OPS.has(char)) {
+      tokens.push({ type: "op", value: char });
+      index += 1;
+      continue;
+    }
+    throw new InvalidFormulaError(`invalid formula syntax: unexpected character '${char}'`);
+  }
+  return tokens;
+}
+function isDigit(char) {
+  return char !== void 0 && char >= "0" && char <= "9";
+}
+function isIdentStart(char) {
+  if (char === void 0) {
+    return false;
+  }
+  return char === "_" || char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+}
+var KEYWORDS = /* @__PURE__ */ new Set(["and", "or", "if", "else"]);
+var CONSTANT_KEYWORDS = /* @__PURE__ */ new Set(["True", "False", "None"]);
+var COMPARE_OPS = {
+  "==": "eq",
+  "!=": "ne",
+  "<": "lt",
+  "<=": "le",
+  ">": "gt",
+  ">=": "ge"
+};
+function parse(expression) {
+  const tokens = tokenize(expression);
+  const parser = new Parser(tokens);
+  const tree = parser.parseExpression();
+  parser.expectEnd();
+  return tree;
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+  }
+  tokens;
+  position = 0;
+  parseExpression() {
+    return this.parseConditional();
+  }
+  expectEnd() {
+    if (this.position < this.tokens.length) {
+      throw new InvalidFormulaError("invalid formula syntax: unexpected trailing tokens");
+    }
+  }
+  parseConditional() {
+    const body = this.parseOr();
+    if (this.matchKeyword("if")) {
+      const test = this.parseOr();
+      this.expectKeyword("else");
+      const orelse = this.parseConditional();
+      return { kind: "ifexp", test, body, orelse };
+    }
+    return body;
+  }
+  parseOr() {
+    const values = [this.parseAnd()];
+    while (this.matchKeyword("or")) {
+      values.push(this.parseAnd());
+    }
+    return values.length === 1 ? values[0] : { kind: "boolop", op: "or", values };
+  }
+  parseAnd() {
+    const values = [this.parseComparison()];
+    while (this.matchKeyword("and")) {
+      values.push(this.parseComparison());
+    }
+    const op = "and";
+    return values.length === 1 ? values[0] : { kind: "boolop", op, values };
+  }
+  parseComparison() {
+    const left = this.parseAdditive();
+    const ops = [];
+    const comparators = [];
+    while (true) {
+      const op = this.peekCompareOp();
+      if (op === void 0) {
+        break;
+      }
+      this.position += 1;
+      ops.push(op);
+      comparators.push(this.parseAdditive());
+    }
+    return ops.length === 0 ? left : { kind: "compare", left, ops, comparators };
+  }
+  parseAdditive() {
+    let node = this.parseMultiplicative();
+    while (true) {
+      const op = this.peekOp();
+      if (op === "+" || op === "-") {
+        this.position += 1;
+        const right = this.parseMultiplicative();
+        node = { kind: "binop", op: op === "+" ? "add" : "sub", left: node, right };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+  parseMultiplicative() {
+    let node = this.parseUnary();
+    while (true) {
+      const op = this.peekOp();
+      if (op === "*" || op === "/" || op === "%") {
+        this.position += 1;
+        const right = this.parseUnary();
+        const kind = op === "*" ? "mul" : op === "/" ? "div" : "mod";
+        node = { kind: "binop", op: kind, left: node, right };
+        continue;
+      }
+      break;
+    }
+    return node;
+  }
+  parseUnary() {
+    const op = this.peekOp();
+    if (op === "+" || op === "-") {
+      this.position += 1;
+      const operand = this.parseUnary();
+      const kind = op === "+" ? "pos" : "neg";
+      return { kind: "unaryop", op: kind, operand };
+    }
+    return this.parsePower();
+  }
+  parsePower() {
+    const base = this.parseAtom();
+    if (this.peekOp() === "**") {
+      this.position += 1;
+      const exponent = this.parseUnary();
+      return { kind: "binop", op: "pow", left: base, right: exponent };
+    }
+    return base;
+  }
+  parseAtom() {
+    const token = this.tokens[this.position];
+    if (token === void 0) {
+      throw new InvalidFormulaError("invalid formula syntax: unexpected end of expression");
+    }
+    if (token.type === "number") {
+      this.position += 1;
+      return { kind: "constant", value: token.value };
+    }
+    if (token.type === "name") {
+      if (CONSTANT_KEYWORDS.has(token.value)) {
+        throw new InvalidFormulaError("only numeric constants are supported");
+      }
+      if (KEYWORDS.has(token.value)) {
+        throw new InvalidFormulaError(
+          `invalid formula syntax: unexpected keyword '${token.value}'`
+        );
+      }
+      this.position += 1;
+      return { kind: "name", id: token.value };
+    }
+    if (token.value === "(") {
+      this.position += 1;
+      const inner = this.parseExpression();
+      this.expectOp(")");
+      return inner;
+    }
+    throw new InvalidFormulaError(`invalid formula syntax: unexpected token '${token.value}'`);
+  }
+  peekOp() {
+    const token = this.tokens[this.position];
+    return token !== void 0 && token.type === "op" ? token.value : void 0;
+  }
+  peekCompareOp() {
+    const op = this.peekOp();
+    return op !== void 0 ? COMPARE_OPS[op] : void 0;
+  }
+  matchKeyword(keyword) {
+    const token = this.tokens[this.position];
+    if (token !== void 0 && token.type === "name" && token.value === keyword) {
+      this.position += 1;
+      return true;
+    }
+    return false;
+  }
+  expectKeyword(keyword) {
+    if (!this.matchKeyword(keyword)) {
+      throw new InvalidFormulaError(`invalid formula syntax: expected '${keyword}'`);
+    }
+  }
+  expectOp(op) {
+    if (this.peekOp() !== op) {
+      throw new InvalidFormulaError(`invalid formula syntax: expected '${op}'`);
+    }
+    this.position += 1;
+  }
+};
+
+// src/calculator/formula-expression/evaluator.ts
+var UNARY_OPS = {
+  pos: (value) => value,
+  neg: (value) => -value
+};
+var BINARY_OPS = {
+  add: (left, right) => left + right,
+  sub: (left, right) => left - right,
+  mul: (left, right) => left * right,
+  div: (left, right) => {
+    if (right === 0) {
+      throw new ZeroDivisionError("float division by zero");
+    }
+    return left / right;
+  },
+  mod: pythonMod,
+  pow: safePow
+};
+var COMPARE_OPS2 = {
+  eq: (left, right) => left === right,
+  ne: (left, right) => left !== right,
+  lt: (left, right) => left < right,
+  le: (left, right) => left <= right,
+  gt: (left, right) => left > right,
+  ge: (left, right) => left >= right
+};
+function pythonMod(left, right) {
+  if (right === 0) {
+    throw new ZeroDivisionError("float modulo");
+  }
+  return left - Math.floor(left / right) * right;
+}
+function safePow(base, exponent) {
+  if (base === 0 && exponent < 0) {
+    throw new ZeroDivisionError("0.0 cannot be raised to a negative power");
+  }
+  const result = base ** exponent;
+  if (!Number.isFinite(result) && Number.isFinite(base) && Number.isFinite(exponent)) {
+    throw new OverflowError("(34, 'Numerical result out of range')");
+  }
+  return result;
+}
+function isTruthy(value) {
+  return value !== 0;
+}
+function evaluateTree(tree, environment, length, hasConditional) {
+  if (hasConditional) {
+    const result = new Array(length);
+    for (let index = 0; index < length; index += 1) {
+      result[index] = evaluateNodeAt(tree, environment, index);
+    }
+    return result;
+  }
+  const value = evaluateNode(tree, environment);
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return new Array(length).fill(value);
+}
+function evaluateNode(node, environment) {
+  switch (node.kind) {
+    case "name": {
+      const series = environment[node.id];
+      return series;
+    }
+    case "constant":
+      return node.value;
+    case "binop": {
+      const left = evaluateNode(node.left, environment);
+      const right = evaluateNode(node.right, environment);
+      return applyBinary(BINARY_OPS[node.op], left, right);
+    }
+    case "unaryop": {
+      const operand = evaluateNode(node.operand, environment);
+      const op = UNARY_OPS[node.op];
+      return Array.isArray(operand) ? operand.map(op) : op(operand);
+    }
+    default:
+      throw new TypeError(`unsupported formula element: ${node.kind}`);
+  }
+}
+function applyBinary(op, left, right) {
+  if (Array.isArray(left)) {
+    if (Array.isArray(right)) {
+      const result = new Array(left.length);
+      for (let index = 0; index < left.length; index += 1) {
+        result[index] = op(left[index], right[index]);
+      }
+      return result;
+    }
+    const scalar = right;
+    return left.map((value) => op(value, scalar));
+  }
+  const scalarLeft = left;
+  if (Array.isArray(right)) {
+    return right.map((value) => op(scalarLeft, value));
+  }
+  return op(scalarLeft, right);
+}
+function evaluateNodeAt(node, environment, index) {
+  switch (node.kind) {
+    case "name": {
+      const series = environment[node.id];
+      return series[index];
+    }
+    case "constant":
+      return node.value;
+    case "binop": {
+      const left = evaluateNodeAt(node.left, environment, index);
+      const right = evaluateNodeAt(node.right, environment, index);
+      return BINARY_OPS[node.op](left, right);
+    }
+    case "unaryop":
+      return UNARY_OPS[node.op](evaluateNodeAt(node.operand, environment, index));
+    case "compare": {
+      let left = evaluateNodeAt(node.left, environment, index);
+      for (let i = 0; i < node.ops.length; i += 1) {
+        const right = evaluateNodeAt(node.comparators[i], environment, index);
+        if (!COMPARE_OPS2[node.ops[i]](left, right)) {
+          return 0;
+        }
+        left = right;
+      }
+      return 1;
+    }
+    case "boolop": {
+      if (node.op === "and") {
+        for (const value of node.values) {
+          if (!isTruthy(evaluateNodeAt(value, environment, index))) {
+            return 0;
+          }
+        }
+        return 1;
+      }
+      for (const value of node.values) {
+        if (isTruthy(evaluateNodeAt(value, environment, index))) {
+          return 1;
+        }
+      }
+      return 0;
+    }
+    case "ifexp": {
+      const test = evaluateNodeAt(node.test, environment, index);
+      const branch = isTruthy(test) ? node.body : node.orelse;
+      return evaluateNodeAt(branch, environment, index);
+    }
+    default:
+      throw new TypeError("unsupported formula element");
+  }
+}
+
+// src/calculator/formula-expression/runtime.ts
+function evaluateCompiled(formula, parameters) {
+  const missing = formula.variables.filter((name) => !Object.hasOwn(parameters, name));
+  if (missing.length > 0) {
+    throw new MissingParameterError(missing);
+  }
+  const environment = {};
+  const lengthsByName = {};
+  for (const [originalName, safeName] of formula.nameMap) {
+    const series = normalizeParameter(originalName, parameters[originalName]);
+    environment[safeName] = series;
+    lengthsByName[originalName] = series.length;
+  }
+  const lengths = Object.values(lengthsByName);
+  if (new Set(lengths).size !== 1) {
+    throw new ParameterLengthError(lengthsByName);
+  }
+  const length = lengths[0];
+  if (length === 0) {
+    return [];
+  }
+  return evaluateTree(formula.tree, environment, length, formula.hasConditional);
+}
+function normalizeParameter(name, value) {
+  if (!Array.isArray(value)) {
+    throw new ParameterError(`parameter '${name}' must be a numeric sequence`);
+  }
+  const normalized = new Array(value.length);
+  for (let index = 0; index < value.length; index += 1) {
+    const item = value[index];
+    if (typeof item !== "number") {
+      throw new ParameterError(`parameter '${name}' must be a numeric sequence`);
+    }
+    normalized[index] = item;
+  }
+  return normalized;
+}
+
+// src/calculator/formula-expression/core.ts
+function evaluate(formula, parameters = {}) {
+  return evaluateCompiled(compileFormula(formula), parameters);
+}
+
+// src/calculator/calculator.ts
+var Calculator = class {
+  retriever;
+  constructor(cognite) {
+    const port = isCognitePort(cognite) ? cognite : createCogniteAdapter(cognite);
+    this.retriever = new DatapointsRetriever(port);
+  }
+  /** Evaluate a single query over the given time range. */
+  async calculate(query, start, end) {
+    const [result] = await this.calculateMultiples([query], start, end);
+    return result;
+  }
+  /**
+   * Evaluate several queries over the given time range, retrieving every
+   * parameter's datapoints in a single de-duplicated round trip.
+   */
+  async calculateMultiples(queries, start, end) {
+    const parameters = queries.flatMap((query) => query.parameters);
+    const datapoints = await this.retriever.retrieveDatapoints(parameters, start, end);
+    const results = [];
+    let offset = 0;
+    for (const query of queries) {
+      const slice = datapoints.slice(offset, offset + query.parameters.length);
+      offset += query.parameters.length;
+      results.push(calculate(query, slice));
+    }
+    return results;
+  }
+};
+function calculate(query, datapoints) {
+  const valuesMap = {};
+  const seriesByAlias = /* @__PURE__ */ new Map();
+  query.parameters.forEach((parameter, index) => {
+    const series = datapoints[index] ?? [];
+    valuesMap[parameter.alias] = series.map((point) => point.value);
+    seriesByAlias.set(parameter.alias, series);
+  });
+  const values = evaluate(query.formula, valuesMap);
+  const [firstVariable] = compileFormula(query.formula).variables;
+  const timestampSeries = seriesByAlias.get(firstVariable) ?? [];
+  return {
+    query,
+    datapoints: timestampSeries.map((point, index) => ({
+      timestamp: point.timestamp,
+      value: values[index]
+    }))
+  };
+}
+function isCognitePort(value) {
+  return typeof value.retrieveDatapoints === "function";
+}
+
+export { ArithmeticError, Calculator, FormulaError, InvalidFormulaError, MissingParameterError, OverflowError, ParameterError, ParameterLengthError, ZeroDivisionError, clearCache, compileFormula, evaluate };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map