@esportsplus/random 0.0.1 → 0.0.3

package/build/coinflip.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => boolean;
+export default _default;

package/build/coinflip.js

@@ -0,0 +1,4 @@
+import rng from './rng';
+export default () => {
+    return rng() < 0.5;
+};

package/build/float.d.ts

@@ -0,0 +1,2 @@
+import rng from './rng';
+export default rng;

package/build/float.js

@@ -0,0 +1,2 @@
+import rng from './rng';
+export default rng;

package/build/floats.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (n: number) => number[];
+export default _default;

package/build/floats.js

@@ -0,0 +1,9 @@
+import rng from './rng';
+import shuffle from './shuffle';
+export default (n) => {
+    let values = [];
+    for (let i = 0; i < n; i++) {
+        values.push(rng());
+    }
+    return shuffle(values);
+};

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 };
+import coinflip from './coinflip';
+import float from './float';
+import floats from './floats';
+import integer from './integer';
+import integers from './integers';
+import item from './item';
+import range from './range';
+import roll from './roll';
+import shuffle from './shuffle';
+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,11 @@
-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 };
+import coinflip from './coinflip';
+import float from './float';
+import floats from './floats';
+import integer from './integer';
+import integers from './integers';
+import item from './item';
+import range from './range';
+import roll from './roll';
+import shuffle from './shuffle';
+export default { coinflip, float, floats, integer, integers, item, range, roll, shuffle };
+export { coinflip, float, floats, integer, integers, item, range, roll, shuffle };

package/build/integer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => number;
+export default _default;

package/build/integer.js

@@ -0,0 +1,4 @@
+import rng from './rng';
+export default () => {
+    return Math.floor(rng());
+};

package/build/integers.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (n: number) => any[];
+export default _default;

package/build/integers.js

@@ -0,0 +1,9 @@
+import rng from './rng';
+import shuffle from './shuffle';
+export default (n) => {
+    let values = [];
+    for (let i = 0; i < n; i++) {
+        values.push(Math.floor(rng()));
+    }
+    return shuffle(values);
+};

package/build/item.d.ts

@@ -0,0 +1,2 @@
+declare const _default: <T>(items: T[], weights?: number[]) => T;
+export default _default;

package/build/item.js

@@ -0,0 +1,25 @@
+import rng from './rng';
+export default (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');
+};

package/build/range.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (min: number, max: number, integer?: boolean) => number;
+export default _default;

package/build/range.js

@@ -0,0 +1,9 @@
+import rng from './rng';
+export default (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);
+};

package/build/rng.d.ts

@@ -0,0 +1,2 @@
+declare let rng: () => number;
+export default rng;

package/build/rng.js

@@ -0,0 +1,11 @@
+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');
+}
+export default rng;

package/build/roll.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (percentage: number) => boolean;
+export default _default;

package/build/roll.js

@@ -0,0 +1,4 @@
+import rng from './rng';
+export default (percentage) => {
+    return rng() <= percentage;
+};

package/build/shuffle.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (values: any[]) => any[];
+export default _default;

package/build/shuffle.js

@@ -0,0 +1,11 @@
+import rng from './rng';
+export default (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;
+};

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.3"
 }

package/src/coinflip.ts

@@ -0,0 +1,6 @@
+import rng from './rng';
+
+
+export default () => {
+    return rng() < 0.5;
+};

package/src/float.ts

@@ -0,0 +1,4 @@
+import rng from './rng';
+
+
+export default rng;

package/src/floats.ts

@@ -0,0 +1,13 @@
+import rng from './rng';
+import shuffle from './shuffle';
+
+
+export default (n: number): number[] => {
+    let values: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        values.push(rng());
+    }
+
+    return shuffle(values);
+};

package/src/index.ts

@@ -1,39 +1,13 @@
-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 = (): number => {
-    if (globalThis?.crypto) {
-        return browser();
-    }
-
-    return node();
-};
-
-// Fisher-Yates shuffle
-// - https://wikipedia.org/wiki/Fisher-Yates_shuffle
-const floats = (n: number): number[] => {
-    let i: number,
-        values: number[] = [];
-
-    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 };
+import coinflip from './coinflip';
+import float from './float';
+import floats from './floats';
+import integer from './integer';
+import integers from './integers';
+import item from './item';
+import range from './range';
+import roll from './roll';
+import shuffle from './shuffle';
+
+
+export default { coinflip, float, floats, integer, integers, item, range, roll, shuffle };
+export { coinflip, float, floats, integer, integers, item, range, roll, shuffle };

package/src/integer.ts

@@ -0,0 +1,6 @@
+import rng from './rng';
+
+
+export default () => {
+    return Math.floor(rng());
+};

package/src/integers.ts

@@ -0,0 +1,13 @@
+import rng from './rng';
+import shuffle from './shuffle';
+
+
+export default (n: number) => {
+    let values: number[] = [];
+
+    for (let i = 0; i < n; i++) {
+        values.push( Math.floor(rng()) );
+    }
+
+    return shuffle(values);
+};

package/src/item.ts

@@ -0,0 +1,36 @@
+import rng from './rng';
+
+
+export default <T>(items: T[], weights?: number[]): T => {
+    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');
+};

package/src/range.ts

@@ -0,0 +1,13 @@
+import rng from './rng';
+
+
+export default (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);
+};

package/src/rng.ts

@@ -0,0 +1,16 @@
+let max = Math.pow(2, 32),
+    rng: () => number;
+
+
+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');
+}
+
+
+export default rng;

package/src/roll.ts

@@ -0,0 +1,6 @@
+import rng from './rng';
+
+
+export default (percentage: number) => {
+    return rng() <= percentage;
+};

package/src/shuffle.ts

@@ -0,0 +1,20 @@
+import rng from './rng';
+
+
+// Fisher-Yates shuffle
+// - https://wikipedia.org/wiki/Fisher-Yates_shuffle
+export default (values: any[]) => {
+    let n = values.length,
+        random: number,
+        value;
+
+    while (--n > 0) {
+        random = Math.floor(rng() * (n + 1));
+        value = values[random];
+
+        values[random] = values[n];
+        values[n] = value;
+    }
+
+    return values;
+};

package/readme.md

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