@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/math.js

@@ -1,75 +1,113 @@
-"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 math_exports = {};
-__export(math_exports, {
-  average: () => average,
-  clamp: () => clamp,
-  linearInterpolate: () => linearInterpolate,
-  linearInterpolateFloat: () => linearInterpolateFloat,
-  maximum: () => maximum,
-  minimum: () => minimum,
-  nthRoot: () => nthRoot,
-  randomFloat: () => randomFloat,
-  randomInt: () => randomInt,
-  round: () => round,
-  sum: () => sum
-});
-module.exports = __toCommonJS(math_exports);
-var import_not_supported_error = require("../error/not-supported.error.js");
-var import_random_number_generator_function = require("../random/number-generator/random-number-generator-function.js");
-function randomFloat(min, max, generator = import_random_number_generator_function.defaultRandomNumberGeneratorFn) {
-  return linearInterpolateFloat(generator(), min, max);
+import { NotSupportedError } from '../error/not-supported.error.js';
+import { defaultRandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
+/**
+ * Generate a random float in interval [min, max).
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator Random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1).
+ * @returns random number (float)
+ */
+export function randomFloat(min, max, generator = defaultRandomNumberGeneratorFn) {
+    return linearInterpolateFloat(generator(), min, max);
 }
-function randomInt(min, max, generator = import_random_number_generator_function.defaultRandomNumberGeneratorFn) {
-  return Math.floor(linearInterpolateFloat(generator(), min, max + 1));
+/**
+ * Generate a random integer in interval [min, max].
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1)
+ * @returns random number (integer)
+ */
+export function randomInt(min, max, generator = defaultRandomNumberGeneratorFn) {
+    return Math.floor(linearInterpolateFloat(generator(), min, max + 1));
 }
-function sum(values) {
-  return values.reduce((previous, current) => previous + current, 0);
+/**
+ * Calculate the sum of all values.
+ * @param values values to sum
+ * @returns sum
+ */
+export function sum(values) {
+    return values.reduce((previous, current) => previous + current, 0);
 }
-function average(values) {
-  return sum(values) / values.length;
+/**
+ * Calculate the average of all values.
+ * @param values values to average
+ * @returns average
+ */
+export function average(values) {
+    return sum(values) / values.length;
 }
-function minimum(values) {
-  if (values.length == 0) {
-    throw new import_not_supported_error.NotSupportedError("No values provided.");
-  }
-  return values.reduce((previous, current) => Math.min(previous, current), Number.POSITIVE_INFINITY);
+/**
+ * Calculate the minimum value.
+ * @param values values to get minimum from
+ * @returns minimum
+ */
+export function minimum(values) {
+    if (values.length == 0) {
+        throw new NotSupportedError('No values provided.');
+    }
+    return values.reduce((previous, current) => Math.min(previous, current), Number.POSITIVE_INFINITY);
 }
-function maximum(values) {
-  if (values.length == 0) {
-    throw new import_not_supported_error.NotSupportedError("No values provided.");
-  }
-  return values.reduce((previous, current) => Math.max(previous, current), Number.NEGATIVE_INFINITY);
+/**
+ * Calculate the maximum value.
+ * @param values values to get maximum from
+ * @returns maximum
+ */
+export function maximum(values) {
+    if (values.length == 0) {
+        throw new NotSupportedError('No values provided.');
+    }
+    return values.reduce((previous, current) => Math.max(previous, current), Number.NEGATIVE_INFINITY);
 }
-function round(value, decimals) {
-  const factor = 10 ** decimals;
-  return Math.round((value + Number.EPSILON) * factor) / factor;
+/**
+ * Round number to specified decimals.
+ * @param value value to round
+ * @param decimals number of decimals to round to
+ * @returns rounded number
+ */
+export function round(value, decimals) {
+    const factor = 10 ** decimals;
+    return Math.round((value + Number.EPSILON) * factor) / factor;
 }
-function linearInterpolate(value, fromLow, fromHigh, toLow, toHigh) {
-  return toLow + (value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow);
+/**
+ * Linearly interpolate the interval [fromLow, fromHigh] into [toLow, toHigh].
+ * @param value value to interpolate
+ * @param fromLow source lower bound
+ * @param fromHigh source upper bound
+ * @param toLow target lower bound
+ * @param toHigh target upper bound
+ * @returns interpolated value
+ */
+export function linearInterpolate(value, fromLow, fromHigh, toLow, toHigh) {
+    return toLow + ((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow));
 }
-function linearInterpolateFloat(value, low, high) {
-  return (1 - value) * low + value * high;
+/**
+ * Linearly interpolate [0, 1] into an interval.
+ * @param value value to interpolate in interval [0, 1]
+ * @param low lower bound
+ * @param high upper bound
+ * @returns interpolated value
+ */
+export function linearInterpolateFloat(value, low, high) {
+    return ((1 - value) * low) + (value * high);
 }
-function clamp(value, minimum2, maximum2) {
-  return Math.min(maximum2, Math.max(minimum2, value));
+/**
+ * Clamps a number between two numbers.
+ * @param value value to clamp
+ * @param minimum lower bound
+ * @param maximum upper bound
+ * @returns clamped value
+ */
+export function clamp(value, minimum, maximum) {
+    return Math.min(maximum, Math.max(minimum, value));
 }
-function nthRoot(base, root) {
-  return base < 0 ? -((-base) ** (1 / root)) : base ** (1 / root);
+/**
+ * Calculates the nth-root of a number.
+ *
+ * Warning: negative values are handled as if they were positive but returned with an negative sign.
+ * @param base base
+ * @param root root
+ * @returns nth-root of base
+ */
+export function nthRoot(base, root) {
+    return (base < 0) ? -((-base) ** (1 / root)) : (base ** (1 / root));
 }

package/utils/merge.js

@@ -1,46 +1,27 @@
-"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 merge_exports = {};
-__export(merge_exports, {
-  merge: () => merge
-});
-module.exports = __toCommonJS(merge_exports);
-var import_type_guards = require("./type-guards.js");
-function merge(a, b) {
-  if ((0, import_type_guards.isUndefined)(a)) {
-    return b;
-  }
-  if ((0, import_type_guards.isUndefined)(b)) {
-    return a;
-  }
-  if ((0, import_type_guards.isObject)(a)) {
-    (0, import_type_guards.assertObject)(b, "Cannot merge object into non-object.");
-    return { ...a, ...b };
-  } else if ((0, import_type_guards.isArray)(a)) {
-    (0, import_type_guards.assertArray)(b, "Cannot merge array into non-array.");
-    return [...a, ...b];
-  } else if ((0, import_type_guards.isMap)(a)) {
-    (0, import_type_guards.assertMap)(b, "Cannot merge map into non-map.");
-    return new Map([...a, ...b]);
-  } else if ((0, import_type_guards.isSet)(a)) {
-    (0, import_type_guards.assertSet)(b, "Cannot merge set into non-set.");
-    return /* @__PURE__ */ new Set([...a, ...b]);
-  }
-  throw new Error("Merging of data can only be done with objects, arrays, maps and sets.");
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+import { assertArray, assertMap, assertObject, assertSet, isArray, isMap, isObject, isSet, isUndefined } from './type-guards.js';
+export function merge(a, b) {
+    if (isUndefined(a)) {
+        return b;
+    }
+    if (isUndefined(b)) {
+        return a;
+    }
+    if (isObject(a)) {
+        assertObject(b, 'Cannot merge object into non-object.');
+        return { ...a, ...b };
+    }
+    else if (isArray(a)) {
+        assertArray(b, 'Cannot merge array into non-array.');
+        return [...a, ...b];
+    }
+    else if (isMap(a)) {
+        assertMap(b, 'Cannot merge map into non-map.');
+        return new Map([...a, ...b]);
+    }
+    else if (isSet(a)) {
+        assertSet(b, 'Cannot merge set into non-set.');
+        return new Set([...a, ...b]);
+    }
+    throw new Error('Merging of data can only be done with objects, arrays, maps and sets.');
 }

package/utils/middleware.js

@@ -1,66 +1,42 @@
-"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 middleware_exports = {};
-__export(middleware_exports, {
-  composeAsyncMiddleware: () => composeAsyncMiddleware,
-  composeMiddleware: () => composeMiddleware
-});
-module.exports = __toCommonJS(middleware_exports);
-function composeMiddleware(middlewares, handler, options = {}) {
-  function composedMiddleware(value, context) {
-    let currentIndex = -1;
-    function dispatch(index, dispatchedValue) {
-      if (index == middlewares.length) {
-        return handler(dispatchedValue, context);
-      }
-      const middleware = middlewares[index];
-      currentIndex = index;
-      function next(nextValue) {
-        if (index < currentIndex && options.allowMultipleNextCalls != true) {
-          throw new Error("next() called multiple times");
+export function composeMiddleware(middlewares, handler, options = {}) {
+    function composedMiddleware(value, context) {
+        let currentIndex = -1;
+        function dispatch(index, dispatchedValue) {
+            if (index == middlewares.length) {
+                return handler(dispatchedValue, context);
+            }
+            const middleware = middlewares[index];
+            currentIndex = index;
+            function next(nextValue) {
+                if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
+                    throw new Error('next() called multiple times');
+                }
+                return dispatch(index + 1, nextValue);
+            }
+            return middleware(dispatchedValue, next, context);
         }
-        return dispatch(index + 1, nextValue);
-      }
-      return middleware(dispatchedValue, next, context);
+        return dispatch(0, value);
     }
-    return dispatch(0, value);
-  }
-  return composedMiddleware;
+    return composedMiddleware;
 }
-function composeAsyncMiddleware(middlewares, handler, options = {}) {
-  async function composedMiddleware(value, context) {
-    let currentIndex = -1;
-    async function dispatch(index, dispatchedValue) {
-      if (index == middlewares.length) {
-        return handler(dispatchedValue, context);
-      }
-      const middleware = middlewares[index];
-      currentIndex = index;
-      async function next(nextValue) {
-        if (index < currentIndex && options.allowMultipleNextCalls != true) {
-          throw new Error("next() called multiple times");
+export function composeAsyncMiddleware(middlewares, handler, options = {}) {
+    async function composedMiddleware(value, context) {
+        let currentIndex = -1;
+        async function dispatch(index, dispatchedValue) {
+            if (index == middlewares.length) {
+                return handler(dispatchedValue, context);
+            }
+            const middleware = middlewares[index];
+            currentIndex = index;
+            async function next(nextValue) {
+                if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
+                    throw new Error('next() called multiple times');
+                }
+                return dispatch(index + 1, nextValue);
+            }
+            return middleware(dispatchedValue, next, context);
         }
-        return dispatch(index + 1, nextValue);
-      }
-      return middleware(dispatchedValue, next, context);
+        return dispatch(0, value);
     }
-    return dispatch(0, value);
-  }
-  return composedMiddleware;
+    return composedMiddleware;
 }