@esportsplus/random 0.0.1 → 0.0.2

package/build/index.d.ts

@@ -1,8 +1,22 @@
-declare const float: () => number;
-declare const floats: (n: number) => number[];
-declare const _default: {
-    float: () => number;
-    floats: (n: number) => number[];
-};
-export default _default;
-export { float, floats };
+declare const coinflip: () => boolean;
+declare const float: () => number;
+declare const floats: (n: number) => number[];
+declare const integer: () => number;
+declare const integers: (n: number) => any[];
+declare const item: <T>(items: T[], weights?: number[]) => T;
+declare const range: (min: number, max: number, integer?: boolean) => number;
+declare const roll: (percentage: number) => boolean;
+declare const shuffle: (values: any[]) => any[];
+declare const _default: {
+    coinflip: () => boolean;
+    float: () => number;
+    floats: (n: number) => number[];
+    integer: () => number;
+    integers: (n: number) => any[];
+    item: <T>(items: T[], weights?: number[] | undefined) => T;
+    range: (min: number, max: number, integer?: boolean) => number;
+    roll: (percentage: number) => boolean;
+    shuffle: (values: any[]) => any[];
+};
+export default _default;
+export { coinflip, float, floats, integer, integers, item, range, roll, shuffle };

package/build/index.js

@@ -1,24 +1,78 @@
-let max = Math.pow(2, 32);
-function browser() {
-    return window.crypto.getRandomValues(new Uint32Array(1))[0] / max;
-}
-function node() {
-    return require('crypto').randomBytes(4).readUInt32BE(0) / max;
-}
-const float = () => {
-    if (globalThis?.crypto) {
-        return browser();
-    }
-    return node();
-};
-const floats = (n) => {
-    let i, values = [];
-    while (--n > -1) {
-        i = Math.floor(Math.random() * (n + 1));
-        values[i] = values[n];
-        values[n] = float();
-    }
-    return values;
-};
-export default { float, floats };
-export { float, floats };
+let max = Math.pow(2, 32), rng;
+if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
+    rng = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / max;
+}
+else if (typeof process !== 'undefined' && process.versions != null && process.versions.node != null) {
+    rng = () => require('crypto').randomBytes(4).readUInt32BE(0) / max;
+}
+else {
+    throw new Error('Random: no suitable random number generator found');
+}
+const coinflip = () => {
+    return rng() < 0.5;
+};
+const float = rng;
+const floats = (n) => {
+    let values = [];
+    for (let i = 0; i < n; i++) {
+        values.push(rng());
+    }
+    return shuffle(values);
+};
+const integer = () => {
+    return Math.floor(rng());
+};
+const integers = (n) => {
+    let values = [];
+    for (let i = 0; i < n; i++) {
+        values.push(Math.floor(rng()));
+    }
+    return shuffle(values);
+};
+const item = (items, weights) => {
+    let random = rng();
+    if (weights === undefined) {
+        return items[Math.floor(random * items.length)];
+    }
+    if (items.length !== weights.length) {
+        throw new Error('Random: each option requires a chance number');
+    }
+    let sum = 0;
+    for (let i = 0, n = weights.length; i < n; i++) {
+        sum += weights[i];
+    }
+    if (sum < .9) {
+        throw new Error('Random: chance numbers need to exceed a total value of .9');
+    }
+    let total = 0;
+    for (let i = 0, n = items.length; i < n; i++) {
+        total += weights[i];
+        if (random <= total) {
+            return items[i];
+        }
+    }
+    throw new Error('Random: weighted option pick failed');
+};
+const range = (min, max, integer = false) => {
+    if (!integer) {
+        return rng() * (max - min) + min;
+    }
+    min = Math.ceil(min);
+    max = Math.floor(max) + 1;
+    return Math.floor(rng() * (max - min) + min);
+};
+const roll = (percentage) => {
+    return rng() <= percentage;
+};
+const shuffle = (values) => {
+    let n = values.length, random, value;
+    while (--n > 0) {
+        random = Math.floor(rng() * (n + 1));
+        value = values[random];
+        values[random] = values[n];
+        values[n] = value;
+    }
+    return values;
+};
+export default { coinflip, float, floats, integer, integers, item, range, roll, shuffle };
+export { coinflip, float, floats, integer, integers, item, range, roll, shuffle };

package/package.json

@@ -2,7 +2,7 @@
     "author": "ICJR",
     "description": "Random",
     "devDependencies": {
-        "@esportsplus/rspack": "^0.0.1"
+        "@esportsplus/rspack": "^0.0.10"
     },
     "main": "build/index.js",
     "name": "@esportsplus/random",
@@ -14,5 +14,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.0.1"
+    "version": "0.0.2"
 }

package/src/index.ts

@@ -1,39 +1,115 @@
-let max = Math.pow(2, 32);
+let max = Math.pow(2, 32),
+    rng: () => number;
 
 
-function browser() {
-    return window.crypto.getRandomValues(new Uint32Array(1))[0] / max;
+if (typeof window !== 'undefined' && typeof window.document !== 'undefined') {
+    rng = () => window.crypto.getRandomValues(new Uint32Array(1))[0] / max;
 }
-
-function node() {
-    return require('crypto').randomBytes(4).readUInt32BE(0) / max;
+else if (typeof process !== 'undefined' && process.versions != null && process.versions.node != null) {
+    rng = () => require('crypto').randomBytes(4).readUInt32BE(0) / max;
+}
+else {
+    throw new Error('Random: no suitable random number generator found');
 }
 
 
-const float = (): number => {
-    if (globalThis?.crypto) {
-        return browser();
+const coinflip = () => {
+    return rng() < 0.5;
+};
+
+const float = rng;
+
+const floats = (n: number): number[] => {
+    let values: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        values.push(rng());
+    }
+
+    return shuffle(values);
+};
+
+const integer = () => {
+    return Math.floor(rng());
+};
+
+const integers = (n: number) => {
+    let values: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        values.push( Math.floor(rng()) );
+    }
+
+    return shuffle(values);
+};
+
+const item = <T>(items: T[], weights?: number[]): T => {
+    let random = rng();
+
+    if (weights === undefined) {
+        return items[ Math.floor(random * items.length) ];
     }
 
-    return node();
+    if (items.length !== weights.length) {
+        throw new Error('Random: each option requires a chance number');
+    }
+
+    let sum = 0;
+
+    for (let i = 0, n = weights.length; i < n; i++) {
+        sum += weights[i];
+    }
+
+    if (sum < .9) {
+        throw new Error('Random: chance numbers need to exceed a total value of .9');
+    }
+
+    let total = 0;
+
+    for (let i = 0, n = items.length; i < n; i++) {
+        total += weights[i];
+
+        if (random <= total) {
+            return items[i];
+        }
+    }
+
+    throw new Error('Random: weighted option pick failed');
+};
+
+const range = (min: number, max: number, integer = false) => {
+    if (!integer) {
+        return rng() * (max - min) + min;
+    }
+
+    min = Math.ceil(min);
+    max = Math.floor(max) + 1;
+
+    return Math.floor(rng() * (max - min) + min);
+};
+
+const roll = (percentage: number) => {
+    return rng() <= percentage;
 };
 
 // Fisher-Yates shuffle
 // - https://wikipedia.org/wiki/Fisher-Yates_shuffle
-const floats = (n: number): number[] => {
-    let i: number,
-        values: number[] = [];
+const shuffle = (values: any[]) => {
+    let n = values.length,
+        random: number,
+        value;
 
-    while(--n > -1) {
-        i = Math.floor(Math.random() * (n + 1));
+    while (--n > 0) {
+        random = Math.floor(rng() * (n + 1));
+        value = values[random];
 
-        values[i] = values[n];
-        values[n] = float();
+        values[random] = values[n];
+        values[n] = value;
     }
 
     return values;
 };
 
 
-export default { float, floats };
-export { float, floats };
+export default { coinflip, float, floats, integer, integers, item, range, roll, shuffle };
+export { coinflip, float, floats, integer, integers, item, range, roll, shuffle };

package/readme.md

@@ -1,2 +0,0 @@
-https://github.com/maverick-js/signals
-https://github.com/modderme123/reactively