@tstdl/base 0.87.13 → 0.88.0-alpha1

package/utils/moving-metric.js

@@ -1,199 +1,166 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var moving_metric_exports = {};
-__export(moving_metric_exports, {
-  MetricAggregation: () => MetricAggregation,
-  MovingMetric: () => MovingMetric
-});
-module.exports = __toCommonJS(moving_metric_exports);
-var import_timer = require("./timer.js");
-var MetricAggregation;
-(function(MetricAggregation2) {
-  MetricAggregation2[MetricAggregation2["Sum"] = 0] = "Sum";
-  MetricAggregation2[MetricAggregation2["Mean"] = 1] = "Mean";
-  MetricAggregation2[MetricAggregation2["Median"] = 2] = "Median";
-  MetricAggregation2[MetricAggregation2["Minimum"] = 3] = "Minimum";
-  MetricAggregation2[MetricAggregation2["Maximum"] = 4] = "Maximum";
-  MetricAggregation2[MetricAggregation2["Count"] = 5] = "Count";
-  MetricAggregation2[MetricAggregation2["Quantile"] = 6] = "Quantile";
-  MetricAggregation2[MetricAggregation2["Rate"] = 7] = "Rate";
-  MetricAggregation2[MetricAggregation2["RateBySum"] = 8] = "RateBySum";
+import { Timer } from './timer.js';
+export var MetricAggregation;
+(function (MetricAggregation) {
+    MetricAggregation[MetricAggregation["Sum"] = 0] = "Sum";
+    MetricAggregation[MetricAggregation["Mean"] = 1] = "Mean";
+    MetricAggregation[MetricAggregation["Median"] = 2] = "Median";
+    MetricAggregation[MetricAggregation["Minimum"] = 3] = "Minimum";
+    MetricAggregation[MetricAggregation["Maximum"] = 4] = "Maximum";
+    MetricAggregation[MetricAggregation["Count"] = 5] = "Count";
+    MetricAggregation[MetricAggregation["Quantile"] = 6] = "Quantile";
+    MetricAggregation[MetricAggregation["Rate"] = 7] = "Rate";
+    MetricAggregation[MetricAggregation["RateBySum"] = 8] = "RateBySum";
 })(MetricAggregation || (MetricAggregation = {}));
-class MovingMetric {
-  interval;
-  samples;
-  constructor(interval) {
-    this.interval = interval;
-    this.samples = [];
-  }
-  add(value) {
-    const timer = new import_timer.Timer(true);
-    const sample = [value, timer];
-    this.samples.push(sample);
-  }
-  aggregate(aggregation, options) {
-    switch (aggregation) {
-      case MetricAggregation.Sum:
-        return this.sum();
-      case MetricAggregation.Mean:
-        return this.mean();
-      case MetricAggregation.Median:
-        return this.median();
-      case MetricAggregation.Minimum:
-        return this.minimum();
-      case MetricAggregation.Maximum:
-        return this.maximum();
-      case MetricAggregation.Count:
-        return this.count();
-      case MetricAggregation.Quantile:
-        if (options == void 0) {
-          throw new Error("quantile requires scalar parameter to be provided");
-        }
-        return this.quantile(options.scalar);
-      case MetricAggregation.Rate:
-        return this.rate();
-      case MetricAggregation.RateBySum:
-        return this.rateBySum();
-      default:
-        throw new Error("unknown aggregation");
-    }
-  }
-  sum(skipRemoveOldSamples = false) {
-    if (!skipRemoveOldSamples) {
-      this.removeOld();
-    }
-    if (this.samples.length == 0) {
-      return NaN;
-    }
-    return this.samples.reduce((sum, [value]) => sum + value, 0);
-  }
-  mean() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
-    }
-    return this.sum(true) / this.samples.length;
-  }
-  // eslint-disable-next-line max-statements
-  median() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
-    }
-    if (this.samples.length == 1) {
-      return this.samples[0][0];
-    }
-    const sortedSamples = this.sortedByValue();
-    if (sortedSamples.length % 2 == 1) {
-      const index = (sortedSamples.length - 1) / 2;
-      return sortedSamples[index][0];
-    }
-    const upperIndex = sortedSamples.length / 2;
-    const [lower] = sortedSamples[upperIndex - 1];
-    const [upper] = sortedSamples[upperIndex];
-    return (lower + upper) / 2;
-  }
-  minimum() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
-    }
-    return this.samples.reduce((minimum, [value]) => Math.min(minimum, value), Number.MAX_VALUE);
-  }
-  maximum() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
-    }
-    return this.samples.reduce((maximum, [value]) => Math.max(maximum, value), Number.MIN_VALUE);
-  }
-  count() {
-    this.removeOld();
-    return this.samples.length;
-  }
-  // eslint-disable-next-line max-statements
-  quantile(scalar) {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
+export class MovingMetric {
+    interval;
+    samples;
+    constructor(interval) {
+        this.interval = interval;
+        this.samples = [];
+    }
+    add(value) {
+        const timer = new Timer(true);
+        const sample = [value, timer];
+        this.samples.push(sample);
+    }
+    aggregate(aggregation, options) {
+        switch (aggregation) {
+            case MetricAggregation.Sum: return this.sum();
+            case MetricAggregation.Mean: return this.mean();
+            case MetricAggregation.Median: return this.median();
+            case MetricAggregation.Minimum: return this.minimum();
+            case MetricAggregation.Maximum: return this.maximum();
+            case MetricAggregation.Count: return this.count();
+            case MetricAggregation.Quantile:
+                if (options == undefined) {
+                    throw new Error('quantile requires scalar parameter to be provided');
+                }
+                return this.quantile(options.scalar);
+            case MetricAggregation.Rate: return this.rate();
+            case MetricAggregation.RateBySum: return this.rateBySum();
+            default: throw new Error('unknown aggregation');
+        }
     }
-    const sortedSamples = this.sortedByValue();
-    const index = Math.round((sortedSamples.length - 1) * scalar);
-    if (Number.isInteger(index)) {
-      const [value] = sortedSamples[index];
-      return value;
+    sum(skipRemoveOldSamples = false) {
+        if (!skipRemoveOldSamples) {
+            this.removeOld();
+        }
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        return this.samples.reduce((sum, [value]) => sum + value, 0);
     }
-    const flooredIndex = Math.floor(index);
-    const [lower] = sortedSamples[flooredIndex];
-    const [upper] = sortedSamples[flooredIndex + 1];
-    const difference = upper - lower;
-    const ratio = index % 1;
-    return lower + ratio * difference;
-  }
-  // eslint-disable-next-line max-statements
-  rate() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
+    mean() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        return this.sum(true) / this.samples.length;
     }
-    if (this.samples.length == 1) {
-      return this.samples[0][0];
+    // eslint-disable-next-line max-statements
+    median() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        if (this.samples.length == 1) {
+            return this.samples[0][0];
+        }
+        const sortedSamples = this.sortedByValue();
+        if (sortedSamples.length % 2 == 1) {
+            const index = (sortedSamples.length - 1) / 2;
+            return sortedSamples[index][0];
+        }
+        const upperIndex = sortedSamples.length / 2;
+        const [lower] = sortedSamples[upperIndex - 1];
+        const [upper] = sortedSamples[upperIndex];
+        return (lower + upper) / 2;
+    }
+    minimum() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        return this.samples.reduce((minimum, [value]) => Math.min(minimum, value), Number.MAX_VALUE);
     }
-    const [oldestValue, oldestTimer] = this.samples[0];
-    const [newestValue, newestTimer] = this.samples[this.samples.length - 1];
-    const delta = newestValue - oldestValue;
-    const seconds = (oldestTimer.milliseconds - newestTimer.milliseconds) / 1e3;
-    const rate = delta / seconds;
-    return rate;
-  }
-  rateBySum() {
-    this.removeOld();
-    if (this.samples.length == 0) {
-      return NaN;
+    maximum() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        return this.samples.reduce((maximum, [value]) => Math.max(maximum, value), Number.MIN_VALUE);
     }
-    if (this.samples.length == 1) {
-      return this.samples[0][0];
+    count() {
+        this.removeOld();
+        return this.samples.length;
     }
-    const sum = this.sum(true);
-    const interval = this.actualInterval(true);
-    const seconds = interval / 1e3;
-    const rate = sum / seconds;
-    return rate;
-  }
-  actualInterval(skipRemoveOldSamples = false) {
-    if (!skipRemoveOldSamples) {
-      this.removeOld();
+    // eslint-disable-next-line max-statements
+    quantile(scalar) {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        const sortedSamples = this.sortedByValue();
+        const index = Math.round((sortedSamples.length - 1) * scalar);
+        if (Number.isInteger(index)) {
+            const [value] = sortedSamples[index];
+            return value;
+        }
+        const flooredIndex = Math.floor(index);
+        const [lower] = sortedSamples[flooredIndex];
+        const [upper] = sortedSamples[flooredIndex + 1];
+        const difference = upper - lower;
+        const ratio = index % 1;
+        return lower + (ratio * difference);
+    }
+    // eslint-disable-next-line max-statements
+    rate() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        if (this.samples.length == 1) {
+            return this.samples[0][0];
+        }
+        const [oldestValue, oldestTimer] = this.samples[0];
+        const [newestValue, newestTimer] = this.samples[this.samples.length - 1];
+        const delta = newestValue - oldestValue;
+        const seconds = (oldestTimer.milliseconds - newestTimer.milliseconds) / 1000;
+        const rate = delta / seconds;
+        return rate;
+    }
+    rateBySum() {
+        this.removeOld();
+        if (this.samples.length == 0) {
+            return NaN;
+        }
+        if (this.samples.length == 1) {
+            return this.samples[0][0];
+        }
+        const sum = this.sum(true);
+        const interval = this.actualInterval(true);
+        const seconds = interval / 1000;
+        const rate = sum / seconds;
+        return rate;
+    }
+    actualInterval(skipRemoveOldSamples = false) {
+        if (!skipRemoveOldSamples) {
+            this.removeOld();
+        }
+        if (this.samples.length <= 1) {
+            return NaN;
+        }
+        const [, oldestTimer] = this.samples[0];
+        const [, newestTimer] = this.samples[this.samples.length - 1];
+        return oldestTimer.milliseconds - newestTimer.milliseconds;
     }
-    if (this.samples.length <= 1) {
-      return NaN;
+    sortedByValue() {
+        return [...this.samples].sort(([a], [b]) => a - b);
     }
-    const [, oldestTimer] = this.samples[0];
-    const [, newestTimer] = this.samples[this.samples.length - 1];
-    return oldestTimer.milliseconds - newestTimer.milliseconds;
-  }
-  sortedByValue() {
-    return [...this.samples].sort(([a], [b]) => a - b);
-  }
-  removeOld() {
-    const firstIndexToKeep = this.samples.findIndex(([, timer]) => timer.milliseconds <= this.interval);
-    if (firstIndexToKeep > 0) {
-      this.samples.splice(0, firstIndexToKeep);
+    removeOld() {
+        const firstIndexToKeep = this.samples.findIndex(([, timer]) => timer.milliseconds <= this.interval);
+        if (firstIndexToKeep > 0) {
+            this.samples.splice(0, firstIndexToKeep);
+        }
     }
-  }
 }

package/utils/noop.js

@@ -1,29 +1,6 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var noop_exports = {};
-__export(noop_exports, {
-  noop: () => noop,
-  noopPass: () => noopPass
-});
-module.exports = __toCommonJS(noop_exports);
-function noop() {
+export function noop() {
+    // noop
 }
-function noopPass(value) {
-  return value;
+export function noopPass(value) {
+    return value;
 }

package/utils/object/decycle.js

@@ -1,85 +1,64 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var decycle_exports = {};
-__export(decycle_exports, {
-  decycle: () => decycle,
-  recycle: () => recycle
-});
-module.exports = __toCommonJS(decycle_exports);
-var import_json_path = require("../../json-path/json-path.js");
-var import_clone = require("../clone.js");
-var import_type_guards = require("../type-guards.js");
-var import_dereference = require("./dereference.js");
-var import_object = require("./object.js");
-function decycle(_value, replacer) {
-  const mapping = /* @__PURE__ */ new Map();
-  const replacerFn = (0, import_type_guards.isDefined)(replacer) ? replacer : (value) => value;
-  function _decycle(__value, path) {
-    const value = replacerFn(__value);
-    if ((0, import_type_guards.isPrimitive)(value) || (0, import_type_guards.isRegExp)(value) || (0, import_type_guards.isDate)(value) || (0, import_type_guards.isFunction)(value)) {
-      return value;
-    }
-    const mappedPath = mapping.get(value);
-    if ((0, import_type_guards.isDefined)(mappedPath)) {
-      return { $ref: mappedPath.path };
-    }
-    mapping.set(value, path);
-    if ((0, import_type_guards.isArray)(value)) {
-      return value.map((item, index) => _decycle(item, path.add(index)));
+import { JsonPath } from '../../json-path/json-path.js';
+import { clone } from '../clone.js';
+import { isArray, isDate, isDefined, isFunction, isNotNull, isObject, isPrimitive, isRegExp, isString, isWritableArray } from '../type-guards.js';
+import { getCachedDereference } from './dereference.js';
+import { hasOwnProperty, mapObjectValues, objectKeys } from './object.js';
+export function decycle(_value, replacer) {
+    const mapping = new Map();
+    const replacerFn = isDefined(replacer) ? replacer : (value) => value;
+    function _decycle(__value, path) {
+        const value = replacerFn(__value);
+        if (isPrimitive(value) || isRegExp(value) || isDate(value) || isFunction(value)) {
+            return value;
+        }
+        const mappedPath = mapping.get(value);
+        if (isDefined(mappedPath)) {
+            return { $ref: mappedPath.path };
+        }
+        mapping.set(value, path);
+        if (isArray(value)) {
+            return value.map((item, index) => _decycle(item, path.add(index)));
+        }
+        return mapObjectValues(value, (item, key) => _decycle(item, path.add(key)));
     }
-    return (0, import_object.mapObjectValues)(value, (item, key) => _decycle(item, path.add(key)));
-  }
-  return _decycle(_value, import_json_path.JsonPath.ROOT);
+    return _decycle(_value, JsonPath.ROOT);
 }
-function recycle(_value, _clone = true) {
-  const value = _clone ? (0, import_clone.clone)(_value, true) : _value;
-  const deref = (0, import_dereference.getCachedDereference)();
-  function getRef(node) {
-    if ((0, import_type_guards.isObject)(node) && (0, import_object.hasOwnProperty)(node, "$ref")) {
-      const ref = node["$ref"];
-      if ((0, import_type_guards.isString)(ref) && import_json_path.JsonPath.isJsonPath(ref)) {
-        return ref;
-      }
+export function recycle(_value, _clone = true) {
+    const value = _clone ? clone(_value, true) : _value;
+    const deref = getCachedDereference();
+    function getRef(node) {
+        if (isObject(node) && hasOwnProperty(node, '$ref')) {
+            const ref = node['$ref'];
+            if (isString(ref) && JsonPath.isJsonPath(ref)) {
+                return ref;
+            }
+        }
+        return undefined;
     }
-    return void 0;
-  }
-  function _recycle(node) {
-    if ((0, import_type_guards.isWritableArray)(node)) {
-      for (let i = 0; i < node.length; i++) {
-        const ref = getRef(node[i]);
-        if ((0, import_type_guards.isDefined)(ref)) {
-          node[i] = deref(value, ref);
-        } else {
-          _recycle(node[i]);
+    function _recycle(node) {
+        if (isWritableArray(node)) {
+            for (let i = 0; i < node.length; i++) {
+                const ref = getRef(node[i]);
+                if (isDefined(ref)) {
+                    node[i] = deref(value, ref);
+                }
+                else {
+                    _recycle(node[i]);
+                }
+            }
         }
-      }
-    } else if ((0, import_type_guards.isObject)(node) && (0, import_type_guards.isNotNull)(node)) {
-      for (const key of (0, import_object.objectKeys)(node)) {
-        const ref = getRef(node[key]);
-        if ((0, import_type_guards.isDefined)(ref)) {
-          node[key] = deref(value, ref);
-        } else {
-          _recycle(node[key]);
+        else if (isObject(node) && isNotNull(node)) {
+            for (const key of objectKeys(node)) {
+                const ref = getRef(node[key]);
+                if (isDefined(ref)) {
+                    node[key] = deref(value, ref);
+                }
+                else {
+                    _recycle(node[key]);
+                }
+            }
         }
-      }
     }
-  }
-  _recycle(value);
-  return value;
+    _recycle(value);
+    return value;
 }

package/utils/object/dereference.js

@@ -1,48 +1,50 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dereference_exports = {};
-__export(dereference_exports, {
-  compileDereferencer: () => compileDereferencer,
-  dereference: () => dereference,
-  getCachedDereference: () => getCachedDereference
-});
-module.exports = __toCommonJS(dereference_exports);
-var import_json_path = require("../../json-path/index.js");
-var import_memoize = require("../function/memoize.js");
-function compileDereferencer(reference) {
-  const nodes = new import_json_path.JsonPath(reference).nodes;
-  function dereferencer(object) {
-    let target = object;
-    for (let i = 0; i < nodes.length; i++) {
-      target = target[nodes[i]];
+import { JsonPath } from '../../json-path/index.js';
+import { memoizeSingle } from '../function/memoize.js';
+/**
+ * compiles a dereferencer for a specific reference
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export function compileDereferencer(reference) {
+    const nodes = new JsonPath(reference).nodes;
+    function dereferencer(object) {
+        let target = object;
+        for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
+            target = target[nodes[i]];
+        }
+        return target;
     }
-    return target;
-  }
-  return dereferencer;
+    return dereferencer;
 }
-function dereference(object, reference) {
-  return compileDereferencer(reference)(object);
+/**
+ * dereference a reference
+ *
+ * @description useful if you dereference a reference a few times at most
+ *
+ * also take a look at {@link getCachedDereference} and {@link compileDereferencer} if you need to dereference multiple times
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export function dereference(object, reference) {
+    return compileDereferencer(reference)(object);
 }
-function getCachedDereference() {
-  const memoizedDereferencer = (0, import_memoize.memoizeSingle)(compileDereferencer);
-  function cachedDereference(object, reference) {
-    return memoizedDereferencer(reference)(object);
-  }
-  return cachedDereference;
+/**
+ * cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ *
+ * @description
+ * useful if you dereference multiple references, each multiple times
+ *
+ * also take a look at {@link dereference} and {@link compileDereferencer} for other use cases
+ * @param object object to dereference
+ * @param reference path to property in dot notation or {@link JsonPath}
+ * @returns referenced value
+ */
+export function getCachedDereference() {
+    const memoizedDereferencer = memoizeSingle(compileDereferencer);
+    function cachedDereference(object, reference) {
+        return memoizedDereferencer(reference)(object);
+    }
+    return cachedDereference;
 }