@stacksjs/arrays 0.70.57 → 0.70.59

package/dist/arr.js

@@ -0,0 +1,3 @@
+export * from "./contains";
+export * from "./helpers";
+export * from "./math";

package/dist/contains.js

@@ -0,0 +1,18 @@
+export function contains(needle, haystack) {
+  return haystack.some((hay) => needle.includes(hay));
+}
+export function containsAll(needles, haystack) {
+  return needles.every((needle) => contains(needle, haystack));
+}
+export function containsAny(needles, haystack) {
+  return needles.some((needle) => contains(needle, haystack));
+}
+export function containsNone(needles, haystack) {
+  return !containsAny(needles, haystack);
+}
+export function containsOnly(needles, haystack) {
+  return containsAll(haystack, needles);
+}
+export function doesNotContain(needle, haystack) {
+  return !contains(needle, haystack);
+}

package/dist/helpers.js

@@ -0,0 +1,85 @@
+import { clamp } from "@stacksjs/utils";
+export function toArray(array) {
+  array = array ?? [];
+  return Array.isArray(array) ? array : [array];
+}
+export function flatten(array) {
+  return toArray(array).reduce((acc, val) => acc.concat(Array.isArray(val) ? flatten(val) : val), []);
+}
+export function mergeArrayable(...args) {
+  return args.flatMap((i) => toArray(i));
+}
+export function partition(array, ...filters) {
+  const result = Array.from({ length: filters.length + 1 }).fill(null).map(() => []);
+  array.forEach((e, idx, arr) => {
+    let i = 0;
+    for (const filter of filters) {
+      if (filter(e, idx, arr)) {
+        result[i].push(e);
+        return;
+      }
+      i += 1;
+    }
+    result[i].push(e);
+  });
+  return result;
+}
+export function uniq(array) {
+  return Array.from(new Set(array));
+}
+export function unique(array) {
+  return uniq(array);
+}
+export function uniqueBy(array, equalFn) {
+  return array.reduce((acc, cur) => {
+    if (acc.findIndex((item) => equalFn(cur, item)) === -1)
+      acc.push(cur);
+    return acc;
+  }, []);
+}
+export function last(array) {
+  return at(array, -1);
+}
+export function remove(array, value) {
+  if (!array)
+    return !1;
+  const index = array.indexOf(value);
+  if (index >= 0) {
+    array.splice(index, 1);
+    return !0;
+  }
+  return !1;
+}
+export function at(array, index) {
+  const len = array.length;
+  if (!len)
+    return;
+  if (index < 0)
+    index += len;
+  return array[index];
+}
+export function move(array, from, to) {
+  const len = array.length;
+  if (!len)
+    return [];
+  if (from < 0)
+    from += len;
+  if (to < 0)
+    to += len;
+  const item = array.splice(from, 1)[0];
+  array.splice(to, 0, item);
+  return array;
+}
+export function clampArrayRange(arr, n) {
+  return clamp(n, 0, arr.length - 1);
+}
+export function sample(arr, count) {
+  return Array.from({ length: count }, () => arr[Math.floor(Math.random() * arr.length)]);
+}
+export function shuffle(array) {
+  for (let i = array.length - 1;i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  }
+  return array;
+}

package/dist/index.js

@@ -1,2 +1,3 @@
-// @bun
-function M(z,E){return E.some((G)=>z.includes(G))}function W(z,E){return z.every((G)=>M(G,E))}function X(z,E){return z.some((G)=>M(G,E))}function D(z,E){return!X(z,E)}function O(z,E){return W(E,z)}function S(z,E){return!M(z,E)}import{clamp as p}from"@stacksjs/utils";function P(z){return z=z??[],Array.isArray(z)?z:[z]}function Y(z){return P(z).reduce((E,G)=>E.concat(Array.isArray(G)?Y(G):G),[])}function T(...z){return z.flatMap((E)=>P(E))}function j(z,...E){let G=Array.from({length:E.length+1}).fill(null).map(()=>[]);return z.forEach((H,I,J)=>{let L=0;for(let U of E){if(U(H,I,J)){G[L].push(H);return}L+=1}G[L].push(H)}),G}function Z(z){return Array.from(new Set(z))}function m(z){return Z(z)}function V(z,E){return z.reduce((G,H)=>{if(G.findIndex((J)=>E(H,J))===-1)G.push(H);return G},[])}function F(z){return _(z,-1)}function N(z,E){if(!z)return!1;let G=z.indexOf(E);if(G>=0)return z.splice(G,1),!0;return!1}function _(z,E){let G=z.length;if(!G)return;if(E<0)E+=G;return z[E]}function R(z,E,G){let H=z.length;if(!H)return[];if(E<0)E+=H;if(G<0)G+=H;let I=z.splice(E,1)[0];return z.splice(G,0,I),z}function C(z,E){return p(E,0,z.length-1)}function $(z,E){return Array.from({length:E},()=>z[Math.floor(Math.random()*z.length)])}function w(z){for(let E=z.length-1;E>0;E--){let G=Math.floor(Math.random()*(E+1));[z[E],z[G]]=[z[G],z[E]]}return z}function K(z){if(z.length===0)throw Error("Cannot compute average of an empty array");return B(z)/z.length}function d(z){return K(z)}function Q(z){if(z.length===0)throw Error("Cannot compute median of an empty array");let E=[...z].sort((I,J)=>I-J),G=Math.floor(E.length/2),H;if(E.length%2!==0)H=E[G];else H=(E[G]+E[G-1])/2;return H}function b(z){if(z.length===0)throw Error("Cannot compute mode of an empty array");let E=new Map;for(let I of z)E.set(I,(E.get(I)||0)+1);let G=0,H=z[0];for(let[I,J]of E)if(J>G)G=J,H=I;return H}function B(z){return z.reduce((E,G)=>E+G,0)}function o(z){let E=1;for(let G of z)if(E*=G,Number.isFinite(E)&&Math.abs(E)>Number.MAX_SAFE_INTEGER)throw RangeError(`[arrays.product] Result exceeds Number.MAX_SAFE_INTEGER (${Number.MAX_SAFE_INTEGER}); use BigInt for large products.`);return E}function x(z){if(z.length===0)throw Error("Cannot compute min of an empty array");return Math.min(...z)}function g(z){if(z.length===0)throw Error("Cannot compute max of an empty array");return Math.max(...z)}function q(z){return g(z)-x(z)}function k(z){let E=K(z);return K(z.map((G)=>(G-E)**2))}function f(z){return Math.sqrt(k(z))}function i(z,E){return(E-K(z))/f(z)}function l(z,E){let G=[...z].sort((U,A)=>U-A),H=E/100*(G.length-1),I=Math.floor(H),J=Math.ceil(H),L=H-I;if(J===I)return G[H]??0;return(1-L)*(G[I]??0)+L*(G[J]??0)}function c(z){let E=Q(z.slice(0,Math.floor(z.length/2)));return Q(z.slice(Math.ceil(z.length/2)))-E}function s(z,E){if(z.length!==E.length)throw Error("Arrays must have the same length");let G=K(z),H=K(E);return K(z.map((I,J)=>(I-G)*(E[J]-H)))}var r={contains(z,E){return M(z,E)},containsAll(z,E){return W(z,E)},containsAny(z,E){return X(z,E)},containsNone(z,E){return D(z,E)},containsOnly(z,E){return O(z,E)},doesNotContain(z,E){return S(z,E)},toArray(z){return P(z)},flatten(z){return Y(z)},mergeArrayable(...z){return T(...z)},partition(z,E){return j(z,E)},random(z,E=1){return $(z,E).filter((G)=>G!=null)},sample(z,E=1){return $(z,E)},unique(z){return Z(z)},uniqueBy(z,E){return V(z,E)},last(z){return F(z)},remove(z,E){return N(z,E)},at(z,E){return _(z,E)},range(z){return q(z)},move(z,E,G){return R(z,E,G)},clampArrayRange(z,E){return C(z,E)},shuffle(z){return w(z)},sum(z){return B(z)},average(z){return K(z)},avg(z){return K(z)},median(z){return Q(z)},mode(z){return b(z)}};export{i as zScore,k as variance,V as uniqueBy,m as unique,Z as uniq,P as toArray,B as sum,f as standardDeviation,w as shuffle,$ as sample,N as remove,q as range,o as product,l as percentile,j as partition,R as move,b as mode,x as min,T as mergeArrayable,Q as median,g as max,F as last,c as interquartileRange,Y as flatten,S as doesNotContain,s as covariance,O as containsOnly,D as containsNone,X as containsAny,W as containsAll,M as contains,C as clampArrayRange,d as avg,K as average,_ as at,Gz as arr,r as Arr};
+export * from "./arr";
+export * as arr from "./arr";
+export * from "./macro";

package/dist/macro.js

@@ -0,0 +1,97 @@
+import { contains, containsAll, containsAny, containsNone, containsOnly, doesNotContain } from "./contains";
+import {
+  at,
+  clampArrayRange,
+  flatten,
+  last,
+  mergeArrayable,
+  move,
+  partition,
+  remove,
+  sample,
+  shuffle,
+  toArray,
+  uniq,
+  uniqueBy
+} from "./helpers";
+import { average, median, mode, range, sum } from "./math";
+export const Arr = {
+  contains(needle, haystack) {
+    return contains(needle, haystack);
+  },
+  containsAll(needles, haystack) {
+    return containsAll(needles, haystack);
+  },
+  containsAny(needles, haystack) {
+    return containsAny(needles, haystack);
+  },
+  containsNone(needles, haystack) {
+    return containsNone(needles, haystack);
+  },
+  containsOnly(needles, haystack) {
+    return containsOnly(needles, haystack);
+  },
+  doesNotContain(needle, haystack) {
+    return doesNotContain(needle, haystack);
+  },
+  toArray(array) {
+    return toArray(array);
+  },
+  flatten(array) {
+    return flatten(array);
+  },
+  mergeArrayable(...args) {
+    return mergeArrayable(...args);
+  },
+  partition(array, filter) {
+    return partition(array, filter);
+  },
+  random(arr, count = 1) {
+    return sample(arr, count).filter((item) => item != null);
+  },
+  sample(arr, count = 1) {
+    return sample(arr, count);
+  },
+  unique(arr) {
+    return uniq(arr);
+  },
+  uniqueBy(arr, equalFn) {
+    return uniqueBy(arr, equalFn);
+  },
+  last(arr) {
+    return last(arr);
+  },
+  remove(arr, value) {
+    return remove(arr, value);
+  },
+  at(arr, index) {
+    return at(arr, index);
+  },
+  range(arr) {
+    return range(arr);
+  },
+  move(arr, from, to) {
+    return move(arr, from, to);
+  },
+  clampArrayRange(arr, n) {
+    return clampArrayRange(arr, n);
+  },
+  shuffle(arr) {
+    return shuffle(arr);
+  },
+  sum(arr) {
+    return sum(arr);
+  },
+  average(arr) {
+    return average(arr);
+  },
+  avg(arr) {
+    return average(arr);
+  },
+  median(arr) {
+    return median(arr);
+  },
+  mode(arr) {
+    return mode(arr);
+  }
+}, arr = Arr;

package/dist/math.js

@@ -0,0 +1,84 @@
+export function average(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute average of an empty array");
+  return sum(arr) / arr.length;
+}
+export function avg(arr) {
+  return average(arr);
+}
+export function median(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute median of an empty array");
+  const sorted = [...arr].sort((a, b) => a - b), mid = Math.floor(sorted.length / 2);
+  let medianValue;
+  if (sorted.length % 2 !== 0)
+    medianValue = sorted[mid];
+  else
+    medianValue = (sorted[mid] + sorted[mid - 1]) / 2;
+  return medianValue;
+}
+export function mode(arr) {
+  if (arr.length === 0)
+    throw Error("Cannot compute mode of an empty array");
+  const counts = new Map;
+  for (const v of arr)
+    counts.set(v, (counts.get(v) || 0) + 1);
+  let maxCount = 0, result = arr[0];
+  for (const [value, count] of counts)
+    if (count > maxCount) {
+      maxCount = count;
+      result = value;
+    }
+  return result;
+}
+export function sum(array) {
+  return array.reduce((acc, cur) => acc + cur, 0);
+}
+export function product(array) {
+  let acc = 1;
+  for (const cur of array) {
+    acc *= cur;
+    if (Number.isFinite(acc) && Math.abs(acc) > Number.MAX_SAFE_INTEGER)
+      throw RangeError(`[arrays.product] Result exceeds Number.MAX_SAFE_INTEGER (${Number.MAX_SAFE_INTEGER}); use BigInt for large products.`);
+  }
+  return acc;
+}
+export function min(array) {
+  if (array.length === 0)
+    throw Error("Cannot compute min of an empty array");
+  return Math.min(...array);
+}
+export function max(array) {
+  if (array.length === 0)
+    throw Error("Cannot compute max of an empty array");
+  return Math.max(...array);
+}
+export function range(array) {
+  return max(array) - min(array);
+}
+export function variance(array) {
+  const mean = average(array);
+  return average(array.map((num) => (num - mean) ** 2));
+}
+export function standardDeviation(array) {
+  return Math.sqrt(variance(array));
+}
+export function zScore(array, num) {
+  return (num - average(array)) / standardDeviation(array);
+}
+export function percentile(array, num) {
+  const sorted = [...array].sort((a, b) => a - b), index = num / 100 * (sorted.length - 1), lower = Math.floor(index), upper = Math.ceil(index), weight = index - lower;
+  if (upper === lower)
+    return sorted[index] ?? 0;
+  return (1 - weight) * (sorted[lower] ?? 0) + weight * (sorted[upper] ?? 0);
+}
+export function interquartileRange(array) {
+  const q1 = median(array.slice(0, Math.floor(array.length / 2)));
+  return median(array.slice(Math.ceil(array.length / 2))) - q1;
+}
+export function covariance(array1, array2) {
+  if (array1.length !== array2.length)
+    throw Error("Arrays must have the same length");
+  const mean1 = average(array1), mean2 = average(array2);
+  return average(array1.map((num1, i) => (num1 - mean1) * (array2[i] - mean2)));
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/arrays",
   "type": "module",
-  "version": "0.70.57",
+  "version": "0.70.59",
   "description": "The Stacks array utilities.",
   "author": "Chris Breuer",
   "contributors": [
@@ -55,7 +55,7 @@
   },
   "devDependencies": {
     "better-dx": "^0.2.12",
-    "@stacksjs/utils": "0.70.57"
+    "@stacksjs/utils": "0.70.59"
   },
   "sideEffects": false
 }