@cloudglides/nox 1.1.0 → 1.1.2

package/example/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "nox-demo",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@cloudglides/nox": "latest",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-react": "^4.2.1",
+    "vite": "^5.0.8"
+  }
+}

package/example/src/App.css

@@ -0,0 +1,161 @@
+.app {
+  width: 100%;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  background: linear-gradient(135deg, #1e1e2e 0%, #2d2d44 100%);
+}
+
+header {
+  padding: 3rem 2rem;
+  text-align: center;
+  border-bottom: 2px solid #646cff;
+}
+
+header h1 {
+  font-size: 3rem;
+  margin-bottom: 0.5rem;
+  background: linear-gradient(45deg, #646cff, #0ea5e9);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+  background-clip: text;
+}
+
+header p {
+  font-size: 1.1rem;
+  color: #a0a0a0;
+}
+
+.tabs {
+  display: flex;
+  gap: 1rem;
+  padding: 2rem;
+  justify-content: center;
+  flex-wrap: wrap;
+  border-bottom: 1px solid #444;
+}
+
+.tabs button {
+  padding: 0.8rem 1.6rem;
+  font-size: 1rem;
+  border: 2px solid transparent;
+  border-radius: 8px;
+  cursor: pointer;
+  transition: all 0.3s;
+  color: #a0a0a0;
+  background: #2d2d44;
+}
+
+.tabs button:hover {
+  color: #646cff;
+  border-color: #646cff;
+}
+
+.tabs button.active {
+  color: #fff;
+  border-color: #646cff;
+  background: #1a1a2e;
+}
+
+.content {
+  flex: 1;
+  padding: 2rem;
+  max-width: 900px;
+  margin: 0 auto;
+  width: 100%;
+}
+
+.section {
+  background: #2d2d44;
+  padding: 2rem;
+  border-radius: 12px;
+  border: 1px solid #444;
+}
+
+.section h2 {
+  margin-bottom: 1.5rem;
+  color: #646cff;
+}
+
+.action-btn {
+  background: linear-gradient(45deg, #646cff, #0ea5e9);
+  color: white;
+  padding: 0.8rem 2rem;
+  font-size: 1rem;
+  border: none;
+  border-radius: 8px;
+  cursor: pointer;
+  font-weight: 600;
+  transition: transform 0.2s, box-shadow 0.2s;
+  margin-bottom: 1.5rem;
+}
+
+.action-btn:hover {
+  transform: translateY(-2px);
+  box-shadow: 0 10px 25px rgba(100, 108, 255, 0.3);
+}
+
+.action-btn:active {
+  transform: translateY(0);
+}
+
+.results {
+  background: #1a1a2e;
+  padding: 1.5rem;
+  border-radius: 8px;
+  border-left: 4px solid #646cff;
+  margin-top: 1rem;
+  font-family: 'Courier New', monospace;
+  word-break: break-all;
+}
+
+.results p {
+  margin: 0.8rem 0;
+  line-height: 1.6;
+}
+
+.results strong {
+  color: #646cff;
+  font-weight: 600;
+}
+
+footer {
+  text-align: center;
+  padding: 2rem;
+  border-top: 1px solid #444;
+  color: #a0a0a0;
+}
+
+footer a {
+  color: #646cff;
+  text-decoration: none;
+  margin: 0 0.5rem;
+}
+
+footer a:hover {
+  text-decoration: underline;
+}
+
+@media (max-width: 768px) {
+  header h1 {
+    font-size: 2rem;
+  }
+
+  .tabs {
+    gap: 0.5rem;
+    padding: 1rem;
+  }
+
+  .tabs button {
+    padding: 0.6rem 1rem;
+    font-size: 0.9rem;
+  }
+
+  .content {
+    padding: 1rem;
+  }
+
+  .section {
+    padding: 1.5rem;
+  }
+}

package/example/src/App.jsx

@@ -0,0 +1,176 @@
+import { useState } from 'react'
+import { rng, deterministic, normal, exponential, meanTest, varianceTest, kolmogorovSmirnovTest } from '@cloudglides/nox'
+import './App.css'
+
+export default function App() {
+  const [tab, setTab] = useState('basic')
+  const [results, setResults] = useState({})
+
+  const runBasic = () => {
+    const r = rng()
+    setResults({
+      float: r.nextFloat().toFixed(6),
+      int: r.int(1, 100),
+      bool: r.bool(0.5),
+      range: r.range(10, 20, 2),
+      choice: r.choice(['apple', 'banana', 'cherry'])
+    })
+  }
+
+  const runBatch = () => {
+    const r = rng()
+    setResults({
+      floats: r.floats(5).map(x => x.toFixed(4)).join(', '),
+      ints: r.ints(5, 100).join(', '),
+      bools: r.bools(5).join(', ')
+    })
+  }
+
+  const runDistributions = () => {
+    const r = rng()
+    const samples = r.floats(100)
+    setResults({
+      normal: Array.from({length: 5}, () => normal(r).toFixed(4)).join(', '),
+      exponential: Array.from({length: 5}, () => exponential(r).toFixed(4)).join(', ')
+    })
+  }
+
+  const runStats = () => {
+    const r = rng()
+    const data = r.floats(1000)
+    const mean = meanTest(data)
+    const variance = varianceTest(data)
+    const ks = kolmogorovSmirnovTest(data)
+    setResults({
+      mean: mean.mean.toFixed(6),
+      variance: variance.variance.toFixed(6),
+      ksPass: ks.pass_0_05 ? 'PASS' : 'FAIL'
+    })
+  }
+
+  const runDeterministic = () => {
+    const r1 = deterministic(42)
+    const seq1 = r1.floats(5)
+    const r2 = deterministic(42)
+    const seq2 = r2.floats(5)
+    setResults({
+      seq1: seq1.map(x => x.toFixed(4)).join(', '),
+      seq2: seq2.map(x => x.toFixed(4)).join(', '),
+      identical: JSON.stringify(seq1) === JSON.stringify(seq2) ? 'YES' : 'NO'
+    })
+  }
+
+  return (
+    <div className="app">
+      <header>
+        <h1>nox - RNG Demo</h1>
+        <p>Unpredictable random number generator with multiple algorithms</p>
+      </header>
+
+      <div className="tabs">
+        <button className={tab === 'basic' ? 'active' : ''} onClick={() => setTab('basic')}>
+          Basic
+        </button>
+        <button className={tab === 'batch' ? 'active' : ''} onClick={() => setTab('batch')}>
+          Batch
+        </button>
+        <button className={tab === 'distributions' ? 'active' : ''} onClick={() => setTab('distributions')}>
+          Distributions
+        </button>
+        <button className={tab === 'stats' ? 'active' : ''} onClick={() => setTab('stats')}>
+          Statistics
+        </button>
+        <button className={tab === 'deterministic' ? 'active' : ''} onClick={() => setTab('deterministic')}>
+          Deterministic
+        </button>
+      </div>
+
+      <div className="content">
+        {tab === 'basic' && (
+          <div className="section">
+            <h2>Basic RNG Operations</h2>
+            <button onClick={runBasic} className="action-btn">Run</button>
+            <div className="results">
+              {results.float && (
+                <div>
+                  <p><strong>nextFloat():</strong> {results.float}</p>
+                  <p><strong>int(1, 100):</strong> {results.int}</p>
+                  <p><strong>bool(0.5):</strong> {results.bool ? 'true' : 'false'}</p>
+                  <p><strong>range(10, 20, 2):</strong> {results.range}</p>
+                  <p><strong>choice():</strong> {results.choice}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'batch' && (
+          <div className="section">
+            <h2>Batch Operations</h2>
+            <button onClick={runBatch} className="action-btn">Run</button>
+            <div className="results">
+              {results.floats && (
+                <div>
+                  <p><strong>floats(5):</strong> [{results.floats}]</p>
+                  <p><strong>ints(5, 100):</strong> [{results.ints}]</p>
+                  <p><strong>bools(5):</strong> [{results.bools}]</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'distributions' && (
+          <div className="section">
+            <h2>Statistical Distributions</h2>
+            <button onClick={runDistributions} className="action-btn">Run</button>
+            <div className="results">
+              {results.normal && (
+                <div>
+                  <p><strong>Normal(0, 1):</strong> [{results.normal}]</p>
+                  <p><strong>Exponential(1):</strong> [{results.exponential}]</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'stats' && (
+          <div className="section">
+            <h2>Statistical Tests</h2>
+            <button onClick={runStats} className="action-btn">Run on 1000 samples</button>
+            <div className="results">
+              {results.mean && (
+                <div>
+                  <p><strong>Mean (expected 0.5):</strong> {results.mean}</p>
+                  <p><strong>Variance (expected 0.083333):</strong> {results.variance}</p>
+                  <p><strong>KS Test (α=0.05):</strong> {results.ksPass}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+
+        {tab === 'deterministic' && (
+          <div className="section">
+            <h2>Deterministic Mode</h2>
+            <button onClick={runDeterministic} className="action-btn">Run with seed=42</button>
+            <div className="results">
+              {results.seq1 && (
+                <div>
+                  <p><strong>Sequence 1:</strong> [{results.seq1}]</p>
+                  <p><strong>Sequence 2:</strong> [{results.seq2}]</p>
+                  <p><strong>Identical:</strong> {results.identical}</p>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+
+      <footer>
+        <p>Visit <a href="https://github.com/cloudglides/nox" target="_blank" rel="noreferrer">GitHub</a> | <a href="https://npmjs.com/package/@cloudglides/nox" target="_blank" rel="noreferrer">npm</a></p>
+      </footer>
+    </div>
+  )
+}

package/example/src/index.css

@@ -0,0 +1,55 @@
+:root {
+  font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+  line-height: 1.5;
+  font-weight: 400;
+  color: rgba(255, 255, 255, 0.87);
+  background-color: #242424;
+}
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  min-width: 320px;
+  min-height: 100vh;
+}
+
+#root {
+  width: 100%;
+  min-height: 100vh;
+}
+
+button {
+  border-radius: 8px;
+  border: 1px solid transparent;
+  padding: 0.6em 1.2em;
+  font-size: 1em;
+  font-weight: 500;
+  font-family: inherit;
+  background-color: #1a1a1a;
+  cursor: pointer;
+  transition: border-color 0.25s;
+}
+
+button:hover {
+  border-color: #646cff;
+}
+
+button:focus,
+button:focus-visible {
+  outline: 4px auto -webkit-focus-ring-color;
+}
+
+@media (prefers-color-scheme: light) {
+  :root {
+    color: #213547;
+    background-color: #ffffff;
+  }
+  button {
+    background-color: #f9f9f9;
+  }
+}

package/example/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

package/example/vite.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  build: {
+    rollupOptions: {
+      external: ['perf_hooks', 'crypto']
+    }
+  }
+})

package/package.json

@@ -1,21 +1,22 @@
 {
   "name": "@cloudglides/nox",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Unpredictable random number generator with multiple algorithms and distributions",
   "type": "module",
   "main": "src/index.js",
   "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "node": "./src/index.js",
+      "browser": "./src/index.browser.js",
+      "default": "./src/index.js"
+    }
+  },
   "scripts": {
     "test": "node test/basic.js",
     "bench": "node test/benchmark.js"
   },
-  "keywords": [
-    "random",
-    "rng",
-    "generator",
-    "chaotic",
-    "stochastic"
-  ],
+  "keywords": ["random", "rng", "generator", "chaotic", "stochastic"],
   "author": "",
   "license": "ISC",
   "packageManager": "pnpm@10.24.0",

package/src/core.browser.js

@@ -0,0 +1,10 @@
+export { rng, RNG } from './rng.browser.js';
+export { deterministic } from './presets.js';
+
+export { normal, exponential, uniform, poisson } from './utils/distributions.js';
+export { shuffle, pick, sample } from './utils/sequence.js';
+export { saveState, restoreState, cloneGenerator } from './utils/state.js';
+export { weightedPick, weightedSample, reservoirSample } from './utils/sampling.js';
+export { meanTest, varianceTest, kolmogorovSmirnovTest } from './utils/statistics.js';
+
+export { combined, clearCryptoCache } from './utils/entropy.browser.js';

package/src/core.js

@@ -6,3 +6,5 @@ export { shuffle, pick, sample } from './utils/sequence.js';
 export { saveState, restoreState, cloneGenerator } from './utils/state.js';
 export { weightedPick, weightedSample, reservoirSample } from './utils/sampling.js';
 export { meanTest, varianceTest, kolmogorovSmirnovTest } from './utils/statistics.js';
+
+export { combined, clearCryptoCache } from './utils/entropy.js';

package/src/index.browser.js

@@ -0,0 +1,31 @@
+export {
+  rng,
+  RNG,
+  deterministic,
+  normal,
+  exponential,
+  uniform,
+  poisson,
+  shuffle,
+  pick,
+  sample,
+  saveState,
+  restoreState,
+  cloneGenerator,
+  weightedPick,
+  weightedSample,
+  reservoirSample,
+  meanTest,
+  varianceTest,
+  kolmogorovSmirnovTest
+} from './core.browser.js';
+
+export {
+  Xorshift64,
+  Splitmix64,
+  PCG64,
+  MT19937,
+  Logistic,
+  Tent,
+  Mixer
+} from './generators/index.js';

package/src/index.js

@@ -29,3 +29,4 @@ export {
   Tent,
   Mixer
 } from './generators/index.js';
+

package/src/presets.js

@@ -1,6 +1,13 @@
 import { RNG } from './rng.js';
 import { PCG64 } from './generators/index.js';
 
+// Use browser or node entropy
+const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+const entropyModule = isNode ? 
+  await import('./utils/entropy.js') : 
+  await import('./utils/entropy.browser.js');
+const { combined: entropyFunc } = entropyModule;
+
 export const deterministic = (seed) => {
   if (seed === null || seed === undefined) {
     throw new TypeError('Deterministic mode requires an explicit seed');

package/src/rng.browser.js

@@ -0,0 +1,141 @@
+import { PCG64 } from './generators/index.js';
+import { combined } from './utils/entropy.browser.js';
+
+export class RNG {
+  constructor(generator = null, seed = null) {
+    if (generator === null) {
+      seed = seed || combined();
+      this.gen = new PCG64(seed);
+    } else if (typeof generator === 'function') {
+      this.gen = new generator(seed || combined());
+    } else if (typeof generator === 'object' && generator !== null) {
+      this.gen = generator;
+    } else {
+      throw new TypeError('Generator must be a constructor function or instance');
+    }
+  }
+
+  next() {
+    return this.gen.next();
+  }
+
+  nextInt(max = 2147483647) {
+    return this.gen.nextInt(max);
+  }
+
+  nextFloat() {
+    return this.gen.nextFloat();
+  }
+
+  int(min, max) {
+    if (typeof min !== 'number' || typeof max !== 'number') {
+      throw new TypeError('int() requires two number arguments');
+    }
+    if (!Number.isInteger(min) || !Number.isInteger(max)) {
+      throw new TypeError('int() arguments must be integers');
+    }
+    if (min > max) [min, max] = [max, min];
+    return Math.floor(this.nextFloat() * (max - min + 1)) + min;
+  }
+
+  bool(probability = 0.5) {
+    if (typeof probability !== 'number') {
+      throw new TypeError('probability must be a number');
+    }
+    if (probability < 0 || probability > 1) {
+      throw new RangeError('probability must be between 0 and 1');
+    }
+    return this.nextFloat() < probability;
+  }
+
+  range(min, max, step = 1) {
+    if (typeof min !== 'number' || typeof max !== 'number' || typeof step !== 'number') {
+      throw new TypeError('min, max, and step must be numbers');
+    }
+    if (!Number.isInteger(min) || !Number.isInteger(max) || !Number.isInteger(step)) {
+      throw new Error('min, max, and step must be integers');
+    }
+    if (step <= 0) {
+      throw new Error('step must be positive');
+    }
+    if (min > max) {
+      throw new Error('min must be less than or equal to max');
+    }
+
+    const count = Math.floor((max - min) / step) + 1;
+    const idx = this.nextInt(count);
+    return min + idx * step;
+  }
+
+  choice(arr) {
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new TypeError('choice() requires non-empty array');
+    }
+    return arr[this.nextInt(arr.length)];
+  }
+
+  batch(count, fn) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+    if (typeof fn !== 'function') {
+      throw new TypeError('fn must be a function');
+    }
+
+    const result = [];
+    for (let i = 0; i < count; i++) {
+      result.push(fn(this, i));
+    }
+    return result;
+  }
+
+  floats(count) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextFloat();
+    }
+    return result;
+  }
+
+  ints(count, max = 2147483647) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.nextInt(max);
+    }
+    return result;
+  }
+
+  bools(count, probability = 0.5) {
+    if (typeof count !== 'number' || !Number.isInteger(count)) {
+      throw new TypeError('count must be an integer');
+    }
+    if (count < 0) {
+      throw new RangeError('count must be non-negative');
+    }
+
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+      result[i] = this.bool(probability);
+    }
+    return result;
+  }
+}
+
+export const rng = () => new RNG();