@esportsplus/random 0.0.2 → 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,12 +1,12 @@
-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[];
+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;

package/build/index.js

@@ -1,78 +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');
-}
-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;
-};
+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

@@ -14,5 +14,5 @@
         "prepublishOnly": "npm run build"
     },
     "types": "build/index.d.ts",
-    "version": "0.0.2"
+    "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,114 +1,12 @@
-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');
-}
-
-
-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) ];
-    }
-
-    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 shuffle = (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;
-};
+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 };

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;
+};