alea-deck 4.1.4 → 5.0.1

package/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2014–2023 Kenan Yildirim <https://kenany.me/>
+Copyright 2014–2026 Kenan Yildirim <https://kenany.me/>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/README.md

@@ -7,15 +7,15 @@ Uniform and weighted shuffling and sampling, just like
 ## Example
 
 ``` javascript
-var deck = require('alea-deck');
+import { shuffle, pick } from 'alea-deck';
 
-deck.shuffle([1, 2, 3, 4]);
+shuffle([1, 2, 3, 4]);
 // => [1, 4, 2, 3]
 
-deck.pick([1, 2, 3, 4]);
+pick([1, 2, 3, 4]);
 // => 2
 
-deck.shuffle({
+shuffle({
   a: 10,
   b: 8,
   c: 2,
@@ -24,7 +24,7 @@ deck.shuffle({
 });
 // => ['b', 'a', 'c', 'd', 'e']
 
-deck.pick({
+pick({
   a: 10,
   b: 8,
   c: 2,
@@ -43,10 +43,22 @@ $ npm install alea-deck
 ## API
 
 ``` javascript
-var deck = require('alea-deck');
+import { deck, shuffle, pick, normalize } from 'alea-deck';
 ```
 
-### `deck.shuffle(collection)`
+### `deck(collection)`
+
+Binds `shuffle` and `pick` to `collection`, returning an object with both
+methods pre-applied.
+
+``` javascript
+const d = deck([1, 2, 3, 4]);
+
+d.shuffle(); // => [3, 1, 4, 2]
+d.pick();    // => 3
+```
+
+### `shuffle(collection)`
 
 If `collection` is an _Array_, returns a new shuffled _Array_ based on a unifrom
 distributionm without mutating the original _Array_.
@@ -54,7 +66,7 @@ distributionm without mutating the original _Array_.
 Otherwise, if `collection` is an _Object_, returns a new shuffled _Array_ of
 `collection`'s visible keys based on the value weights of `collection`.
 
-### `deck.pick(collection)`
+### `pick(collection)`
 
 Samples `collection` without mutating `collection`.
 
@@ -64,7 +76,7 @@ uniform distribution.
 Otherwise, if `collection` is an _Object_, returns a random key from
 `collection` biased by its normalized value.
 
-### `deck.normalize(obj)`
+### `normalize(obj)`
 
 Return a new `obj` _Object_ where the values have been divided by the sum of all
 the values such that the sum of all the values in the returned _Object_ is 1.

package/dist/index.cjs

@@ -0,0 +1,100 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _thi_ng_checks = require("@thi.ng/checks");
+let alea_random = require("alea-random");
+alea_random = __toESM(alea_random);
+//#region src/index.ts
+function deck(xs) {
+	if (!(Array.isArray(xs) || (0, _thi_ng_checks.isPlainObject)(xs))) throw new TypeError("Must be an Array or an Object");
+	return {
+		shuffle: shuffle.bind(null, xs),
+		pick: pick.bind(null, xs)
+	};
+}
+function shuffle(xs) {
+	if (Array.isArray(xs)) {
+		const res = xs.slice();
+		for (let i = res.length - 1; i >= 0; i--) {
+			const n = Math.floor((0, alea_random.default)(0, 1, true) * i);
+			const t = res[i];
+			res[i] = res[n];
+			res[n] = t;
+		}
+		return res;
+	}
+	if ((0, _thi_ng_checks.isPlainObject)(xs)) {
+		const weights = { ...xs };
+		const ret = [];
+		while (Object.keys(weights).length > 0) {
+			const key = pick(weights);
+			delete weights[key];
+			ret.push(key);
+		}
+		return ret;
+	}
+	throw new TypeError("Must be an Array or an Object");
+}
+function pick(xs) {
+	if (Array.isArray(xs)) {
+		if (xs.length === 0) return;
+		return xs[Math.floor((0, alea_random.default)(0, 1, true) * xs.length)];
+	}
+	if ((0, _thi_ng_checks.isPlainObject)(xs)) {
+		const weights = normalize(xs);
+		if (!weights) return;
+		const n = (0, alea_random.default)(0, 1, true);
+		let threshold = 0;
+		const keyz = Object.keys(weights);
+		for (const key of keyz) {
+			threshold += weights[key];
+			if (n < threshold) return key;
+		}
+		throw new Error("Exceeded threshold. Something is very wrong.");
+	}
+	throw new TypeError("Must be an Array or an Object");
+}
+/**
+* Returns a copy of `weights` where every value has been divided by the total
+* so that all values sum to 1. Returns `undefined` for an empty object.
+*/
+function normalize(weights) {
+	if (!(0, _thi_ng_checks.isPlainObject)(weights)) throw new TypeError("`weights` must be an object");
+	const keyz = Object.keys(weights);
+	if (!keyz.length) return;
+	const total = keyz.reduce((sum, key) => {
+		const x = weights[key];
+		if (x < 0) throw new Error(`Negative weight encountered at key ${key}`);
+		if (typeof x !== "number" || Number.isNaN(x)) throw new TypeError(`Number expected, got ${typeof x}`);
+		return sum + x;
+	}, 0);
+	return total === 1 ? weights : keyz.reduce((acc, key) => {
+		acc[key] = weights[key] / total;
+		return acc;
+	}, {});
+}
+//#endregion
+exports.deck = deck;
+exports.normalize = normalize;
+exports.pick = pick;
+exports.shuffle = shuffle;

package/dist/index.d.cts

@@ -0,0 +1,40 @@
+//#region src/index.d.ts
+type WeightMap = Record<string, number>;
+/**
+ * Binds `shuffle` and `pick` to the given collection, returning an object
+ * with both methods pre-applied to `xs`.
+ */
+declare function deck<T>(xs: readonly T[]): {
+  shuffle: () => T[];
+  pick: () => T | undefined;
+};
+declare function deck(xs: WeightMap): {
+  shuffle: () => string[];
+  pick: () => string | undefined;
+};
+/**
+ * Returns a shuffled copy of `xs` without mutating the original.
+ *
+ * If `xs` is an Array, elements are reordered with uniform probability.
+ * If `xs` is an Object, returns a shuffled array of its keys weighted by
+ * their values.
+ */
+declare function shuffle<T>(xs: readonly T[]): T[];
+declare function shuffle(xs: WeightMap): string[];
+/**
+ * Samples a single element from `xs` without mutating it.
+ *
+ * If `xs` is an Array, returns a uniformly random element, or `undefined` if
+ * the array is empty.
+ * If `xs` is an Object, returns a key sampled with probability proportional to
+ * its normalized weight, or `undefined` if the object is empty.
+ */
+declare function pick<T>(xs: readonly T[]): T | undefined;
+declare function pick(xs: WeightMap): string | undefined;
+/**
+ * Returns a copy of `weights` where every value has been divided by the total
+ * so that all values sum to 1. Returns `undefined` for an empty object.
+ */
+declare function normalize(weights: WeightMap): WeightMap | undefined;
+//#endregion
+export { deck, normalize, pick, shuffle };

package/dist/index.d.mts

@@ -0,0 +1,40 @@
+//#region src/index.d.ts
+type WeightMap = Record<string, number>;
+/**
+ * Binds `shuffle` and `pick` to the given collection, returning an object
+ * with both methods pre-applied to `xs`.
+ */
+declare function deck<T>(xs: readonly T[]): {
+  shuffle: () => T[];
+  pick: () => T | undefined;
+};
+declare function deck(xs: WeightMap): {
+  shuffle: () => string[];
+  pick: () => string | undefined;
+};
+/**
+ * Returns a shuffled copy of `xs` without mutating the original.
+ *
+ * If `xs` is an Array, elements are reordered with uniform probability.
+ * If `xs` is an Object, returns a shuffled array of its keys weighted by
+ * their values.
+ */
+declare function shuffle<T>(xs: readonly T[]): T[];
+declare function shuffle(xs: WeightMap): string[];
+/**
+ * Samples a single element from `xs` without mutating it.
+ *
+ * If `xs` is an Array, returns a uniformly random element, or `undefined` if
+ * the array is empty.
+ * If `xs` is an Object, returns a key sampled with probability proportional to
+ * its normalized weight, or `undefined` if the object is empty.
+ */
+declare function pick<T>(xs: readonly T[]): T | undefined;
+declare function pick(xs: WeightMap): string | undefined;
+/**
+ * Returns a copy of `weights` where every value has been divided by the total
+ * so that all values sum to 1. Returns `undefined` for an empty object.
+ */
+declare function normalize(weights: WeightMap): WeightMap | undefined;
+//#endregion
+export { deck, normalize, pick, shuffle };

package/dist/index.mjs

@@ -0,0 +1,73 @@
+import { isPlainObject } from "@thi.ng/checks";
+import random from "alea-random";
+//#region src/index.ts
+function deck(xs) {
+	if (!(Array.isArray(xs) || isPlainObject(xs))) throw new TypeError("Must be an Array or an Object");
+	return {
+		shuffle: shuffle.bind(null, xs),
+		pick: pick.bind(null, xs)
+	};
+}
+function shuffle(xs) {
+	if (Array.isArray(xs)) {
+		const res = xs.slice();
+		for (let i = res.length - 1; i >= 0; i--) {
+			const n = Math.floor(random(0, 1, true) * i);
+			const t = res[i];
+			res[i] = res[n];
+			res[n] = t;
+		}
+		return res;
+	}
+	if (isPlainObject(xs)) {
+		const weights = { ...xs };
+		const ret = [];
+		while (Object.keys(weights).length > 0) {
+			const key = pick(weights);
+			delete weights[key];
+			ret.push(key);
+		}
+		return ret;
+	}
+	throw new TypeError("Must be an Array or an Object");
+}
+function pick(xs) {
+	if (Array.isArray(xs)) {
+		if (xs.length === 0) return;
+		return xs[Math.floor(random(0, 1, true) * xs.length)];
+	}
+	if (isPlainObject(xs)) {
+		const weights = normalize(xs);
+		if (!weights) return;
+		const n = random(0, 1, true);
+		let threshold = 0;
+		const keyz = Object.keys(weights);
+		for (const key of keyz) {
+			threshold += weights[key];
+			if (n < threshold) return key;
+		}
+		throw new Error("Exceeded threshold. Something is very wrong.");
+	}
+	throw new TypeError("Must be an Array or an Object");
+}
+/**
+* Returns a copy of `weights` where every value has been divided by the total
+* so that all values sum to 1. Returns `undefined` for an empty object.
+*/
+function normalize(weights) {
+	if (!isPlainObject(weights)) throw new TypeError("`weights` must be an object");
+	const keyz = Object.keys(weights);
+	if (!keyz.length) return;
+	const total = keyz.reduce((sum, key) => {
+		const x = weights[key];
+		if (x < 0) throw new Error(`Negative weight encountered at key ${key}`);
+		if (typeof x !== "number" || Number.isNaN(x)) throw new TypeError(`Number expected, got ${typeof x}`);
+		return sum + x;
+	}, 0);
+	return total === 1 ? weights : keyz.reduce((acc, key) => {
+		acc[key] = weights[key] / total;
+		return acc;
+	}, {});
+}
+//#endregion
+export { deck, normalize, pick, shuffle };

package/package.json

@@ -1,49 +1,64 @@
 {
   "name": "alea-deck",
-  "version": "4.1.4",
+  "version": "5.0.1",
   "description": "Uniform and weighted shuffling and sampling with Alea",
   "keywords": [
     "alea",
     "math",
     "random"
   ],
-  "repository": "github:kenany/alea-deck",
   "license": "MIT",
   "author": "Kenan Yildirim <kenan@kenany.me> (https://kenany.me/)",
-  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kenany/alea-deck.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "commonjs",
+  "types": "dist/index.d.cts",
+  "main": "dist/index.cjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./*.mjs": {
+      "default": "./dist/*.mjs"
+    },
+    "./*.cjs": {
+      "default": "./dist/*.cjs"
+    },
+    "./*": {
+      "import": "./dist/*.mjs",
+      "require": "./dist/*.cjs"
+    }
+  },
   "files": [
-    "index.js",
+    "dist",
     "LICENSE.txt"
   ],
-  "directories": {
-    "test": "test"
-  },
   "engines": {
-    "node": "18 || >=20"
-  },
-  "scripts": {
-    "lint": "eslint *.js test/*.js",
-    "test": "tape test/*.js",
-    "posttest": "npm run lint",
-    "release": "semantic-release"
+    "node": "22 || 24 || >=26"
   },
   "dependencies": {
-    "alea-random": "^5.0.4",
-    "lodash.isnumber": "^3.0.3",
-    "lodash.isplainobject": "^4.0.6",
-    "lodash.keys": "^4.2.0",
-    "lodash.reduce": "^4.6.0"
+    "@thi.ng/checks": "^3.10.0",
+    "alea-random": "^6.0.1"
   },
   "devDependencies": {
-    "@kenan/eslint-config": "^11.1.11",
-    "@semantic-release/changelog": "^6.0.3",
-    "@semantic-release/git": "^10.0.1",
-    "conventional-changelog-conventionalcommits": "^8.0.0",
-    "eslint": "^8.57.1",
-    "lodash.every": "^4.6.0",
-    "lodash.isundefined": "^3.0.1",
-    "lodash.map": "^4.6.0",
-    "semantic-release": "^24.2.3",
-    "tape": "^5.9.0"
+    "@biomejs/biome": "2.4.16",
+    "@containerbase/semantic-release-pnpm": "1.4.1",
+    "@kenan/biome-config": "1.0.6",
+    "conventional-changelog-conventionalcommits": "9.3.1",
+    "semantic-release": "25.0.3",
+    "tsdown": "0.22.2",
+    "typescript": "6.0.3",
+    "vitest": "4.1.8"
+  },
+  "scripts": {
+    "build": "tsdown && tsc --noEmit",
+    "lint": "biome check",
+    "test": "vitest run"
   }
-}
+}

package/index.js

@@ -1,111 +0,0 @@
-const random = require('alea-random');
-const isPlainObject = require('lodash.isplainobject');
-const keys = require('lodash.keys');
-const reduce = require('lodash.reduce');
-const isNumber = require('lodash.isnumber');
-
-function deck(xs) {
-  if (!Array.isArray(xs) && !isPlainObject(xs)) {
-    throw new TypeError('Must be an Array or an Object');
-  }
-
-  return reduce(keys(module.exports), function(acc, name) {
-    acc[name] = module.exports[name].bind(null, xs);
-    return acc;
-  }, {});
-}
-
-function shuffle(xs) {
-  if (Array.isArray(xs)) {
-    const res = xs.slice();
-    for (let i = res.length - 1; i >= 0; i--) {
-      const n = Math.floor(random(true) * i);
-      const t = res[i];
-      res[i] = res[n];
-      res[n] = t;
-    }
-    return res;
-  }
-  else if (isPlainObject(xs)) {
-    const weights = reduce(keys(xs), function(acc, key) {
-      acc[key] = xs[key];
-      return acc;
-    }, {});
-
-    const ret = [];
-
-    while (keys(weights).length > 0) {
-      const key = pick(weights);
-      delete weights[key];
-      ret.push(key);
-    }
-
-    return ret;
-  }
-  else {
-    throw new TypeError('Must be an Array or an Object');
-  }
-}
-
-function pick(xs) {
-  if (Array.isArray(xs)) {
-    return xs[Math.floor(random(true) * xs.length)];
-  }
-  else if (isPlainObject(xs)) {
-    const weights = normalize(xs);
-    if (!weights) {
-      return undefined;
-    }
-
-    const n = random(true);
-    let threshold = 0;
-    const keyz = keys(weights);
-
-    for (let i = 0; i < keyz.length; i++) {
-      threshold += weights[keyz[i]];
-      if (n < threshold) {
-        return keyz[i];
-      }
-    }
-    throw new Error('Exceeded threshold. Something is very wrong.');
-  }
-  else {
-    throw new TypeError('Must be an Array or an Object');
-  }
-}
-
-function normalize(weights) {
-  if (!isPlainObject(weights)) {
-    throw new TypeError('`weights` must be an object');
-  }
-
-  const keyz = keys(weights);
-  if (!keyz.length) {
-    return undefined;
-  }
-
-  const total = reduce(keyz, function(sum, key) {
-    const x = weights[key];
-    if (x < 0) {
-      throw new Error('Negative weight encountered at key ' + key);
-    }
-    else if (!isNumber(x)) {
-      throw new TypeError('Number expected, got ' + typeof x);
-    }
-    else {
-      return sum + x;
-    }
-  }, 0);
-
-  return total === 1
-    ? weights
-    : reduce(keyz, function(acc, key) {
-      acc[key] = weights[key] / total;
-      return acc;
-    }, {});
-}
-
-module.exports = deck;
-module.exports.shuffle = shuffle;
-module.exports.pick = pick;
-module.exports.normalize = normalize;