@andrew_l/toolkit 0.2.4 → 0.2.7

package/dist/index.cjs

@@ -1,11 +1,11 @@
 'use strict';
 
-const _get = require('lodash/get');
-const _cloneDeep = require('lodash/cloneDeep');
-const _cloneDeepWith = require('lodash/cloneDeepWith');
-const _defaultsDeep = require('lodash/defaultsDeep');
-const _set = require('lodash/set');
-const _unset = require('lodash/unset');
+const _get = require('lodash/get.js');
+const _cloneDeep = require('lodash/cloneDeep.js');
+const _cloneDeepWith = require('lodash/cloneDeepWith.js');
+const _defaultsDeep = require('lodash/defaultsDeep.js');
+const _set = require('lodash/set.js');
+const _unset = require('lodash/unset.js');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -248,6 +248,30 @@ function difference(...arrays) {
   return Array.from(set);
 }
 
+function groupBy(array, keyBy, objectMode) {
+  const getItemKey = isFunction(keyBy) ? keyBy : (item) => item?.[keyBy];
+  let key;
+  if (objectMode === true) {
+    const result2 = {};
+    for (const item of array) {
+      key = getItemKey(item);
+      result2[key] = result2[key] || [];
+      result2[key].push(item);
+    }
+    return result2;
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const item of array) {
+    key = getItemKey(item);
+    if (!result.has(key)) {
+      result.set(key, [item]);
+    } else {
+      result.get(key).push(item);
+    }
+  }
+  return result;
+}
+
 function intersection(...arrays) {
   if (arrays.length === 0) return [];
   if (arrays.length === 1) return arrays[0];
@@ -358,6 +382,7 @@ let AssertionError;
     (r) => r.BrowserAssertionError
   ) : await import('node:assert').then((r) => r.AssertionError);
 })();
+
 function ok(value, message) {
   if (!value) {
     throw toError$1(
@@ -379,6 +404,11 @@ function equal(actual, expected, message) {
     });
   }
 }
+function empty$1(value, message) {
+  if (isEmpty(value)) {
+    throw toError$1(empty$1, value, message, "Expected not empty value.");
+  }
+}
 function object(value, message) {
   if (!isObject(value)) {
     throw toError$1(object, value, message, "Expected object value.");
@@ -409,6 +439,36 @@ function number$1(value, message) {
     throw toError$1(number$1, value, message, "Expected number value.");
   }
 }
+function date(value, message) {
+  if (!isDate(value)) {
+    throw toError$1(date, value, message, "Expected date value.");
+  }
+}
+function fn(value, message) {
+  if (!isNumber(value)) {
+    throw toError$1(fn, value, message, "Expected function value.");
+  }
+}
+function greaterThan(value, target, message) {
+  if (!isNumber(value) || value < target) {
+    throw toError$1(
+      greaterThan,
+      value,
+      message,
+      "Expected number value greater then " + target + "."
+    );
+  }
+}
+function lessThan(value, target, message) {
+  if (!isNumber(value) || value > target) {
+    throw toError$1(
+      lessThan,
+      value,
+      message,
+      "Expected number value less then " + target + "."
+    );
+  }
+}
 function array(value, message) {
   if (!Array.isArray(value)) {
     throw toError$1(array, value, message, "Expected array value.");
@@ -442,7 +502,12 @@ const assert = {
   arrayNumbers: arrayNumbers,
   arrayStrings: arrayStrings,
   boolean: boolean,
+  date: date,
+  empty: empty$1,
   equal: equal,
+  fn: fn,
+  greaterThan: greaterThan,
+  lessThan: lessThan,
   notEmptyString: notEmptyString,
   number: number$1,
   object: object,
@@ -450,6 +515,53 @@ const assert = {
   string: string
 };
 
+function weightedRoundRobin(arr) {
+  ok(arr.length > 0, "Array must contain at least one item.");
+  const instance = new WeightedRoundRobin(
+    arr.map((v) => ({
+      item: v.item,
+      weight: Math.min(v.weight ?? 1, 1)
+    }))
+  );
+  return () => instance.nextItem();
+}
+const gcd = (a, b) => !b ? a : gcd(b, a % b);
+class WeightedRoundRobin {
+  constructor(items) {
+    this.items = items;
+    this.maxWeight = this._calculateMaxWeight();
+    this.gcdWeight = this._calculateGCD();
+  }
+  currentIndex = -1;
+  currentWeight = 0;
+  maxWeight;
+  gcdWeight;
+  _calculateGCD() {
+    return this.items.reduce(
+      (acc, curr) => gcd(acc, curr.weight),
+      this.items[0].weight
+    );
+  }
+  _calculateMaxWeight() {
+    return Math.max(...this.items.map((s) => s.weight));
+  }
+  nextItem() {
+    const n = this.items.length;
+    while (true) {
+      this.currentIndex = (this.currentIndex + 1) % n;
+      if (this.currentIndex === 0) {
+        this.currentWeight -= this.gcdWeight;
+        if (this.currentWeight <= 0) {
+          this.currentWeight = this.maxWeight;
+        }
+      }
+      if (this.items[this.currentIndex].weight >= this.currentWeight) {
+        return this.items[this.currentIndex].item;
+      }
+    }
+  }
+}
+
 class Base64Encoding {
   alphabet;
   padding;
@@ -658,13 +770,12 @@ const def = (obj, key, value, writable = false) => {
 const rndCharacters = "abcdefghijklmnopqrstuvwxyz0123456789";
 const charactersLength = rndCharacters.length;
 function randomString(length) {
-  let result = "";
-  for (let i = 0; i < length; i++) {
-    result += rndCharacters.charAt(
-      Math.floor(Math.random() * charactersLength)
-    );
+  let str = "";
+  let num = isNumber(length) ? Math.max(0, length) : 0;
+  while (num--) {
+    str += rndCharacters[charactersLength * Math.random() | 0];
   }
-  return result;
+  return str;
 }
 
 const objectKeys = /* @__PURE__ */ new WeakMap();
@@ -1457,27 +1568,57 @@ function flatten(obj, {
   isObjectCompare = isObject
 } = {}) {
   const result = {};
-  const processed = /* @__PURE__ */ new WeakSet();
-  const handle = (node, prefix, initial) => {
-    if (processed.has(node)) return;
-    if (isObjectCompare(node)) {
-      processed.add(node);
-      prefix = prefix && !initial ? `${prefix}${separator}` : prefix;
-      for (const [key, value] of Object.entries(node)) {
-        handle(value, `${prefix}${key}`);
-      }
+  const seen = /* @__PURE__ */ new WeakSet();
+  if (isObjectCompare(obj)) {
+    iter(
+      result,
+      seen,
+      isObjectCompare,
+      separator,
+      withArrays,
+      obj,
+      initialPrefix,
+      true
+    );
+  }
+  return result;
+}
+function iter(output, seen, isObjectCompare, separator, withArrays, val, key, initial) {
+  if (seen.has(val)) return;
+  let k, pfx = key && !initial ? key + separator : key;
+  if (Array.isArray(val)) {
+    seen.add(val);
+    if (!withArrays) {
+      output[key] = val;
       return;
     }
-    if (Array.isArray(node) && withArrays) {
-      processed.add(node);
-      prefix = prefix && !initial ? `${prefix}${separator}` : prefix;
-      node.forEach((value, idx) => handle(value, `${prefix}${idx}`));
-      return;
+    for (k = 0; k < val.length; k++) {
+      iter(
+        output,
+        seen,
+        isObjectCompare,
+        separator,
+        withArrays,
+        val[k],
+        pfx + k
+      );
     }
-    result[prefix] = node;
-  };
-  handle(obj, initialPrefix, true);
-  return result;
+  } else if (isObjectCompare(val)) {
+    seen.add(val);
+    for (k in val) {
+      iter(
+        output,
+        seen,
+        isObjectCompare,
+        separator,
+        withArrays,
+        val[k],
+        pfx + k
+      );
+    }
+  } else {
+    output[key] = val;
+  }
 }
 
 function has(value, keys) {
@@ -1558,12 +1699,40 @@ const toMap = (obj) => {
   return map;
 };
 
-function unflatten(obj, separator = "_") {
-  const result = {};
-  Object.keys(obj).forEach((path) => {
-    set(result, path.split(separator), obj[path]);
-  });
-  return result;
+const badKeys = Object.freeze(
+  /* @__PURE__ */ new Set(["constructor", "__proto__", "prototype"])
+);
+function unflatten(input, separator = "_") {
+  if (!isObject(input)) {
+    return {};
+  }
+  let arr, tmp, output;
+  let i = 0, k, key;
+  for (k in input) {
+    tmp = output;
+    arr = k.split(separator);
+    for (i = 0; i < arr.length; ) {
+      key = arr[i++];
+      if (tmp == null) {
+        tmp = empty(+key);
+        output = output || tmp;
+      }
+      if (badKeys.has(key)) break;
+      if (i < arr.length) {
+        if (key in tmp) {
+          tmp = tmp[key];
+        } else {
+          tmp = tmp[key] = empty(+arr[i]);
+        }
+      } else {
+        tmp[key] = input[k];
+      }
+    }
+  }
+  return output;
+}
+function empty(key) {
+  return key === key ? [] : {};
 }
 
 const unset = _unset__default;
@@ -3188,7 +3357,7 @@ function getFileExtension(name, withDot = true) {
     return null;
   }
   const ext = name.split(".").at(-1)?.split("?")?.at(0);
-  return ext ? withDot ? ext : `.${ext}` : null;
+  return ext ? withDot ? `.${ext}` : ext : null;
 }
 
 const DEF_PROTOCOLS = ["http://", "https://"];
@@ -3206,7 +3375,21 @@ function getFileName(value) {
   if (!ext) {
     return value;
   }
-  return value.slice(0, -ext.length - 1);
+  return value.slice(0, -ext.length);
+}
+
+function getMostSpecificPaths(keys) {
+  keys = [...keys].sort();
+  const result = [];
+  for (let i = 0; i < keys.length; i++) {
+    const currentPath = keys[i];
+    const nextPath = keys[i + 1];
+    if (currentPath === nextPath) continue;
+    if (!nextPath || !nextPath.startsWith(currentPath + ".")) {
+      result.push(currentPath);
+    }
+  }
+  return result;
 }
 
 function humanFileSize(bytes, digits = 1, withSpace = true) {
@@ -3308,19 +3491,37 @@ function tryStringify(o) {
   }
 }
 
-const IS_DEV = env.isDevelopment || env.bool("DEV", false);
+const LEVEL_NUM = {
+  debug: 0,
+  log: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+let currentLogLevel = LEVEL_NUM.log;
+const loggerSetLevel = (level) => {
+  number$1(LEVEL_NUM[level], `Invalid log level: ${level}`);
+  currentLogLevel = LEVEL_NUM[level];
+};
 const logger = (...baseArgs) => {
+  if (isString(baseArgs[0]?.url)) {
+    baseArgs[0] = baseArgs[0]?.url;
+  }
   if (typeof baseArgs[0] === "string" && baseArgs[0][0] !== "[") {
     baseArgs[0] = `[${baseArgs[0].split("/").at(-1).split("?", 1)[0]}]`;
   }
   const writeLog = (level, ...[pattern, ...args]) => {
+    const levelNum = LEVEL_NUM[level];
+    if (levelNum < currentLogLevel) {
+      return;
+    }
     if (!isString(pattern)) {
       console[level](...baseArgs, pattern, ...args);
       return;
     }
     const unusedArgs = [];
     const formatted = sprintf(pattern, args, unusedArgs);
-    console[level](...baseArgs, ...formatted, ...unusedArgs);
+    console[level](...baseArgs, formatted, ...unusedArgs);
   };
   const log = writeLog.bind(null, "log");
   const info = writeLog.bind(null, "info");
@@ -3338,9 +3539,6 @@ const logger = (...baseArgs) => {
     debug,
     extend
   };
-  Object.defineProperty(instance, "debug", {
-    get: () => IS_DEV ? debug : noop
-  });
   return instance;
 };
 
@@ -4325,9 +4523,11 @@ exports.get = get;
 exports.getFileExtension = getFileExtension;
 exports.getFileName = getFileName;
 exports.getInitials = getInitials;
+exports.getMostSpecificPaths = getMostSpecificPaths;
 exports.getRandomInt = getRandomInt;
 exports.getRandomTime = getRandomTime;
 exports.getWords = getWords;
+exports.groupBy = groupBy;
 exports.has = has;
 exports.hasOwn = hasOwn;
 exports.hasProtocol = hasProtocol;
@@ -4377,6 +4577,7 @@ exports.isoToFlagEmoji = isoToFlagEmoji;
 exports.kebabCase = kebabCase;
 exports.keyBy = keyBy;
 exports.logger = logger;
+exports.loggerSetLevel = loggerSetLevel;
 exports.lowerCase = lowerCase;
 exports.luminance = luminance;
 exports.maskingEmail = maskingEmail;
@@ -4431,6 +4632,7 @@ exports.uniq = uniq;
 exports.uniqBy = uniqBy;
 exports.unset = unset;
 exports.weeksInYear = weeksInYear;
+exports.weightedRoundRobin = weightedRoundRobin;
 exports.withCache = withCache;
 exports.withCacheBucket = withCacheBucket;
 exports.withCacheBucketBatch = withCacheBucketBatch;