@karmaniverous/entity-manager 5.0.8 → 6.0.0

package/dist/mjs/node_modules/radash/dist/esm/array.js

@@ -0,0 +1,80 @@
+import { isFunction, isArray } from './typed.js';
+
+function zipToObject(keys, values) {
+  if (!keys || !keys.length) {
+    return {};
+  }
+  const getValue = isFunction(values) ? values : isArray(values) ? (_k, i) => values[i] : (_k, _i) => values;
+  return keys.reduce((acc, key, idx) => {
+    acc[key] = getValue(key, idx);
+    return acc;
+  }, {});
+}
+const sort = (array, getter, desc = false) => {
+  if (!array)
+    return [];
+  const asc = (a, b) => getter(a) - getter(b);
+  const dsc = (a, b) => getter(b) - getter(a);
+  return array.slice().sort(desc === true ? dsc : asc);
+};
+const counting = (list2, identity) => {
+  if (!list2)
+    return {};
+  return list2.reduce((acc, item) => {
+    const id = identity(item);
+    acc[id] = (acc[id] ?? 0) + 1;
+    return acc;
+  }, {});
+};
+const objectify = (array, getKey, getValue = (item) => item) => {
+  return array.reduce((acc, item) => {
+    acc[getKey(item)] = getValue(item);
+    return acc;
+  }, {});
+};
+const cluster = (list2, size = 2) => {
+  const clusterCount = Math.ceil(list2.length / size);
+  return new Array(clusterCount).fill(null).map((_c, i) => {
+    return list2.slice(i * size, i * size + size);
+  });
+};
+const unique = (array, toKey) => {
+  const valueMap = array.reduce((acc, item) => {
+    const key = toKey ? toKey(item) : item;
+    if (acc[key])
+      return acc;
+    acc[key] = item;
+    return acc;
+  }, {});
+  return Object.values(valueMap);
+};
+function* range(startOrLength, end, valueOrMapper = (i) => i, step = 1) {
+  const mapper = isFunction(valueOrMapper) ? valueOrMapper : () => valueOrMapper;
+  const start = end ? startOrLength : 0;
+  const final = end ?? startOrLength;
+  for (let i = start; i <= final; i += step) {
+    yield mapper(i);
+    if (i + step > final)
+      break;
+  }
+}
+const list = (startOrLength, end, valueOrMapper, step) => {
+  return Array.from(range(startOrLength, end, valueOrMapper, step));
+};
+const fork = (list2, condition) => {
+  if (!list2)
+    return [[], []];
+  return list2.reduce(
+    (acc, item) => {
+      const [a, b] = acc;
+      if (condition(item)) {
+        return [[...a, item], b];
+      } else {
+        return [a, [...b, item]];
+      }
+    },
+    [[], []]
+  );
+};
+
+export { cluster, counting, fork, list, objectify, range, sort, unique, zipToObject };

package/dist/mjs/node_modules/radash/dist/esm/async.js

@@ -0,0 +1,58 @@
+import { list, fork, sort } from './array.js';
+import { isPromise } from './typed.js';
+
+class AggregateError extends Error {
+  constructor(errors = []) {
+    super();
+    const name = errors.find((e) => e.name)?.name ?? "";
+    this.name = `AggregateError(${name}...)`;
+    this.message = `AggregateError with ${errors.length} errors`;
+    this.stack = errors.find((e) => e.stack)?.stack ?? this.stack;
+    this.errors = errors;
+  }
+}
+const parallel = async (limit, array, func) => {
+  const work = array.map((item, index) => ({
+    index,
+    item
+  }));
+  const processor = async (res) => {
+    const results2 = [];
+    while (true) {
+      const next = work.pop();
+      if (!next)
+        return res(results2);
+      const [error, result] = await tryit(func)(next.item);
+      results2.push({
+        error,
+        result,
+        index: next.index
+      });
+    }
+  };
+  const queues = list(1, limit).map(() => new Promise(processor));
+  const itemResults = await Promise.all(queues);
+  const [errors, results] = fork(
+    sort(itemResults.flat(), (r) => r.index),
+    (x) => !!x.error
+  );
+  if (errors.length > 0) {
+    throw new AggregateError(errors.map((error) => error.error));
+  }
+  return results.map((r) => r.result);
+};
+const tryit = (func) => {
+  return (...args) => {
+    try {
+      const result = func(...args);
+      if (isPromise(result)) {
+        return result.then((value) => [void 0, value]).catch((err) => [err, void 0]);
+      }
+      return [void 0, result];
+    } catch (err) {
+      return [err, void 0];
+    }
+  };
+};
+
+export { AggregateError, parallel, tryit };

package/dist/mjs/node_modules/radash/dist/esm/object.js

@@ -0,0 +1,22 @@
+const shake = (obj, filter = (x) => x === void 0) => {
+  if (!obj)
+    return {};
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    if (filter(obj[key])) {
+      return acc;
+    } else {
+      acc[key] = obj[key];
+      return acc;
+    }
+  }, {});
+};
+const mapValues = (obj, mapFunc) => {
+  const keys2 = Object.keys(obj);
+  return keys2.reduce((acc, key) => {
+    acc[key] = mapFunc(obj[key], key);
+    return acc;
+  }, {});
+};
+
+export { mapValues, shake };

package/dist/mjs/node_modules/radash/dist/esm/typed.js

@@ -0,0 +1,28 @@
+const isArray = Array.isArray;
+const isFunction = (value) => {
+  return !!(value && value.constructor && value.call && value.apply);
+};
+const isString = (value) => {
+  return typeof value === "string" || value instanceof String;
+};
+const isInt = (value) => {
+  return isNumber(value) && value % 1 === 0;
+};
+const isNumber = (value) => {
+  try {
+    return Number(value) === value;
+  } catch {
+    return false;
+  }
+};
+const isPromise = (value) => {
+  if (!value)
+    return false;
+  if (!value.then)
+    return false;
+  if (!isFunction(value.then))
+    return false;
+  return true;
+};
+
+export { isArray, isFunction, isInt, isNumber, isPromise, isString };

package/dist/mjs/node_modules/string-hash/index.js

@@ -0,0 +1,21 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+
+function hash(str) {
+  var hash = 5381,
+      i    = str.length;
+
+  while(i) {
+    hash = (hash * 33) ^ str.charCodeAt(--i);
+  }
+
+  /* JavaScript does bitwise operations (like XOR, above) on 32-bit signed
+   * integers. Since we want the results to be always positive, convert the
+   * signed int to an unsigned by doing an unsigned bitshift. */
+  return hash >>> 0;
+}
+
+var stringHash = hash;
+
+var stringHash$1 = /*@__PURE__*/getDefaultExportFromCjs(stringHash);
+
+export { stringHash$1 as default };

package/dist/mjs/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,36 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __classPrivateFieldGet, __classPrivateFieldSet };