refactor: replace randomIntByModel, randomIntInclusiveByModel wit…

…h `randomByModel`

BREAKING CHANGE:
- Removed `randomIntByModel`, `randomIntInclusiveByModel`
- Rewritten `randomByModel`

README.md

@@ -9,19 +9,6 @@ yarn add extra-rand
 ```
 
 ## API
-```ts
-type IRandomModel =
-| number
-| {
-    min: number
-    max: number
-  }
-| NonEmptyArray<{
-    weight: number
-    value: IRandomModel
-  }>
-```
-
 ### random
 ```ts
 function random(min: number, max: number): number
@@ -76,17 +63,26 @@ function randomByWeightModel<T>(model: IWeightModel<T>): number
 
 ### randomByModel
 ```ts
-function randomByModel(model: IRandomModel): number
-```
+enum Type {
+  Float
+, Integer
+, IntegerInclusive
+}
 
-### randomIntByModel
-```ts
-function randomIntByModel(model: IRandomModel): number
-```
+type IRandomModel =
+| number
+| Getter<number>
+| {
+    type: Type
+    min: number
+    max: number
+  }
+| NonEmptyArray<{
+    weight: number
+    value: IRandomModel
+  }>
 
-### randomIntInclusiveByModel
-```ts
-function randomIntInclusiveByModel(model: IRandomModel): number
+function randomByModel(model: IRandomModel): number
 ```
 
 ### mapToRange

__tests__/random-by-model.spec.ts

@@ -1,6 +1,5 @@
 import { describe, test, expect } from 'vitest'
-import { randomByModel } from '@src/random-by-model.js'
-import { IRandomModel } from '@src/types.js'
+import { randomByModel, IRandomModel, Type } from '@src/random-by-model.js'
 
 describe('randomByModel', () => {
   test('number', () => {
@@ -13,20 +12,66 @@ describe('randomByModel', () => {
     }
   })
 
-  test('min, max', () => {
-    const model: IRandomModel = {
-      min: 0.1
-    , max: 9.9
-    }
+  test('getter', () => {
+    const value = 0.5
+    const model: IRandomModel = () => value
 
     for (let i = 10000; i--;) {
       const result = randomByModel(model)
 
-      expect(result).toBeGreaterThanOrEqual(model.min)
-      expect(result).toBeLessThan(model.max)
+      expect(result).toBe(value)
     }
   })
 
+  describe('min, max', () => {
+    test('float', () => {
+      const model: IRandomModel = {
+        type: Type.Float
+      , min: 0.1
+      , max: 9.9
+      }
+
+      for (let i = 10000; i--;) {
+        const result = randomByModel(model)
+
+        expect(result).toBeGreaterThanOrEqual(model.min)
+        expect(result).toBeLessThan(model.max)
+      }
+    })
+
+    test('integer', () => {
+      const model: IRandomModel = {
+        type: Type.Integer
+      , min: 0.1
+      , max: 9.9
+      }
+
+      for (let i = 10000; i--;) {
+        const result = randomByModel(model)
+
+        expect(Number.isInteger(result)).toBe(true)
+        expect(result).toBeGreaterThanOrEqual(Math.ceil(model.min))
+        expect(result).toBeLessThan(Math.floor(model.max))
+      }
+    })
+
+    test('integer inclusive', () => {
+      const model: IRandomModel = {
+        type: Type.IntegerInclusive
+      , min: 0.1
+      , max: 9.9
+      }
+
+      for (let i = 10000; i--;) {
+        const result = randomByModel(model)
+
+        expect(Number.isInteger(result)).toBe(true)
+        expect(result).toBeGreaterThanOrEqual(Math.ceil(model.min))
+        expect(result).toBeLessThanOrEqual(Math.floor(model.max))
+      }
+    })
+  })
+
   test('weighted', () => {
     const loops = 10000
     const model: IRandomModel = [

src/index.ts

@@ -1,5 +1,3 @@
-export { IRandomModel } from './types.js'
-
 export * from './random.js'
 export * from './random-int.js'
 export * from './random-int-inclusive.js'
@@ -8,8 +6,6 @@ export * from './random-index-by-weight.js'
 export * from './random-weighted.js'
 export * from './random-by-weight-model.js'
 export * from './random-by-model.js'
-export * from './random-int-by-model.js'
-export * from './random-int-inclusive-by-model.js'
 
 export * from './map-to-range.js'
 export * from './map-to-index-by-weight.js'

src/random-by-model.ts

@@ -1,16 +1,43 @@
-import { isArray, isNumber } from 'extra-utils'
+import { Getter, NonEmptyArray } from 'justypes'
+import { isArray, isFunction, isNumber } from 'extra-utils'
 import { randomByWeightModel } from './random-by-weight-model.js'
-import { IRandomModel } from './types.js'
 import { random } from './random.js'
+import { randomInt } from './random-int.js'
+import { randomIntInclusive } from './random-int-inclusive.js'
+
+export enum Type {
+  Float
+, Integer
+, IntegerInclusive
+}
+
+export type IRandomModel =
+| number
+| Getter<number>
+| {
+    type: Type
+    min: number
+    max: number
+  }
+| NonEmptyArray<{
+    weight: number
+    value: IRandomModel
+  }>
 
 export function randomByModel(model: IRandomModel): number {
   if (isNumber(model)) {
     return model
   } else if (isArray(model)) {
     const subModel = randomByWeightModel(model)
     return randomByModel(subModel)
+  } else if (isFunction(model)) {
+    return model()
   } else {
-    const { min, max } = model
-    return random(min, max)
+    const { type, min, max } = model
+    switch (type) {
+      case Type.Float: return random(min, max)
+      case Type.Integer: return randomInt(min, max)
+      case Type.IntegerInclusive: return randomIntInclusive(min, max)
+    }
   }
 }