@nejs/basic-extensions 2.21.0 → 2.22.6

package/package.json

@@ -1,36 +1,30 @@
 {
   "author": "Brielle Harrison <nyteshade at gmail.com>",
-  "browser": "dist/@nejs/basic-extensions.bundle.2.21.0.js",
+  "browser": "dist/@nejs/basic-extensions.bundle.2.22.6.js",
   "description": "Basic but commonly used extensions",
   "dependencies": {
-    "@nejs/extension": "^2.20.0",
-    "zod": "^3.23.8"
+    "@nejs/extension": "^2.20.0"
   },
   "devDependencies": {
-    "docdash": "^2.0.2",
-    "documentation": "^14.0.3",
     "esbuild": "^0.25.3",
-    "esdoc": "^0.0.2",
-    "esdoc-standard-plugin": "^1.0.0",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.5.4",
     "vitest": "^3.1.2"
   },
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "exports": {
     ".": {
-      "import": "./dist/mjs/index.js",
-      "require": "./dist/cjs/index.js"
+      "browser": "./dist/esm/basic-extensions.mjs",
+      "import": "./src/index.js",
+      "require": "./dist/cjs/index.cjs"
     },
     "./classes": {
-      "import": "./dist/mjs/classes/index.js",
-      "require": "./dist/cjs/classes/index.js"
+      "import": "./src/classes/index.js",
+      "require": "./dist/cjs/classes/index.cjs"
     },
     "./utils": {
-      "import": "./dist/mjs/utils/index.js",
-      "require": "./dist/cjs/utils/index.js"
+      "import": "./src/utils/index.js",
+      "require": "./dist/cjs/utils/index.cjs"
     }
   },
   "keywords": [
@@ -39,18 +33,18 @@
     "localStorage"
   ],
   "license": "MIT",
-  "main": "dist/cjs/index.js",
-  "module": "dist/mjs/index.js",
+  "main": "dist/cjs/index.cjs",
+  "module": "src/index.js",
   "name": "@nejs/basic-extensions",
   "scripts": {
+    "build": "bin/clean && bin/version patch bump && bin/esbuild",
+    "distribute": "bin/clean && bin/version minor bump && bin/esbuild && npm publish",
     "browser": "bin/esbuild",
-    "build": "bin/clean && bin/version patch bump && bin/esbuild && bin/build",
     "clean": "bin/clean",
-    "distribute": "bin/clean && bin/version minor bump && bin/esbuild && bin/build",
-    "module": "bin/build",
+    "prepack": "bin/clean && bin/esbuild",
     "repl": "npm run build && node --no-warnings repl.bootstrap.js",
     "test": "vitest"
   },
   "type": "module",
-  "version": "2.21.0"
+  "version": "2.22.6"
 }

package/repl.bootstrap.js

@@ -1,18 +1,15 @@
 #!/usr/bin/env node --no-warnings --no-deprecations --enable-source-maps
 
 // Import everything for playtesting.
-(await import('./dist/mjs/index.js')).Controls.enableAll();
+(await import('./src/index.js')).Controls.enableAll();
 (await import('./bin/repl.signature.js'))
 
-// Grab typescript
-const ts = await import('typescript')
-
 const {
   accessor, data, describe, describeMany, extract, isDescriptor,
   isAccessor, isData, redescribe,
-} = await import('./dist/mjs/utils/index.js')
+} = await import('./src/utils/index.js')
 
-const { inspect } = await import('util');
+const { inspect } = await import('node:util');
 const nejsExtension = await import('@nejs/extension');
 
 const repl = await import('node:repl');
@@ -53,7 +50,7 @@ replServer = createRepl({
     Extension: nejsExtension.Extension,
 
     accessor, data, describe, describeMany, extract, inspect,
-    isAccessor, isData, isDescriptor, redescribe, ts,
+    isAccessor, isData, isDescriptor, redescribe,
   },
   onReady() {
     console.log(help())

package/repl.history

@@ -1,30 +1,30 @@
-/exit
-Object.setPrototypeOf(m, pop)
-pop[Symbol.toStringTag] = 'Map'
-pop[Symbol.toStringTag] = 'Map
-Object.setPrototypeOf(m, p)
-m2 = new Map()
-m.name
-Object.setPrototypeOf(m, pop)
-pop = new Proxy(p, { get(t,p,r) { if (t.has.call(m, p)) { return t.get.call(m, p) } return Reflect.get(t,p,r) }, has(t,p) { if (t.has.call(m, p)) { return true } return Reflect.has(t,p) } })
-p.has.call(m, 'name')
-p.has('name')
-Object.setPrototypeOf(m, pop)
-pop = new Proxy(p, { get(t,p,r) { if (m.has(p)) { return m.get(p) } return Reflect.get(t,p,r) }, has(t,p) { if (m.has(p)) { return true } return Reflect.has(t,p) } })
-Object.setPrototypeOf(m, pop)
-pop = new Proxy(p, { get(t,p,r) { if (t.has(p)) { return t.get(p) } return Reflect.get(t,p,r) }, has(t,p) { if (t.has(p)) { return true } return Reflect.has(t,p) } })
-np = Object.create(p)
-p = Object.getPrototypeOf(m)
-m.get('name')
-m = new Map([['name', 'Brielle']])
-ObjectPatches.patchesOwner
-ObjectPatches.patchsOwner
-ObjectPatches.patchCount
-[...ObjectPatches.patchEntries]
-ObjectPatches = Patches.get(Object)
-Patches.get(Object)
-[...Patches.keys()]
-Object.keys(Patches)
-Patches.keys()
-var { Extensions, Patches } = (await import ('./dist/cjs/index.js'))
-(await import ('./dist/cjs/index.js')).Patchest import ('./dist/cjs/index.js')).Extensionsex.js').Extensions.js').Patchesx.js').patchesndex.js')mport ('.')og','This is being logged'], ['error', 'But something terrible happened'])p('Fun', ['log','This is being logged'], ['error', 'But something terrible happened']).print()ics','underline']).print()int() { console.log(this) }brave new world', ['italics','underline']))['italics','underline'])
+.exit
+.help
+clear
+is
+.exit
+is.objectKey(/asdfads/)
+is.objectKey(Symbol())
+is.objectKey('asdfads')
+is.objectKey(234)
+is.objectEntry([Symbol(), 234])
+is.objectEntry(['name', 234])
+is.objectEntry(['name', 'Brie'])
+is
+var { is, si, has, as } = await import('./dist/mjs/index.js')
+is.objectEntry(['name', 'Brie'])
+Colors.red
+class Colors extends Enumeration { static { Colors.define('red') } }
+Enumeration 
+toolkit.is.a(undefined, undefined)
+toolkit.is.a(undefined, 'undefined')
+toolkit = await import('./src/utils/toolkit.js')
+await import('./src/utils/toolkit.js')
+.exit
+await import('./src/toolkit.js')
+is
+(20n).within(10n, 20n, false)
+(20n).within(10n, 20n, true)
+(30n).within(10n, 20n, true)
+(33n).within(10n, 20n, true)
+(-33n).within(10n, 20n, true)).within(10n, 20n)).clamp(10n, 30n)t.max(10n, BigInt.min(30n, -33n))3n.clamp(10n, 30n)tExtensions.apply(); BigIntPrototypeExtensions.apply() BigIntPrototypeExtensions } = await import('./dist/mjs/big.int.extension.js') BigIntPrototypeExtensions.apply()sions, BigIntPrototypeExtensions } = await import('./dist/mjs/big.int.extension.js') -33n))gIntPrototypeExtensions } = await import('./dist/mjs/big.int.extension.js')h.extension.js')p) } })get(p) } return Reflect.get(t,p,r) }, has(t,p) { if (t.has(p)) { return true } return Reflect.has(t,p) } })ypeOf(m)ame')ame', 'Brielle']])wner')mport ('.')og','This is being logged'], ['error', 'But something terrible happened'])p('Fun', ['log','This is being logged'], ['error', 'But something terrible happened']).print()ics','underline']).print()int() { console.log(this) }brave new world', ['italics','underline']))['italics','underline'])

package/src/big.int.extension.js

@@ -15,52 +15,126 @@ import { Patch } from '@nejs/extension'
  * // Now the `BigInt` class has additional methods available
  */
 export const BigIntExtensions = new Patch(BigInt, {
-  /**
-   * Determines if the supplied `value` is a `BigInt`. This check is
-   * performed by first checking the `typeof` the `value` and then
-   * checking to see if the `value` is an `instanceof` `BigInt`
-   *
-   * @param {*} value The value that needs to be checked to determine
-   * if it is a `BigInt` or not
-   * @returns {boolean} `true` if the supplied `value` is a `BigInt`,
-   * `false` otherwise
-   *
-   * @example
-   * const bigInt = 1234567890123456789012345678901234567890n
-   * isBigInt(bigInt) // true
-   * isBigInt(1234567890123456789012345678901234567890) // false
-   * isBigInt('1234567890123456789012345678901234567890') // false
-   * isBigInt(BigInt('1234567890123456789012345678901234567890')) // true
-   */
-  isBigInt(value) {
-    return typeof value === 'bigint' || value instanceof BigInt
-  },
+  [Patch.kMutablyHidden]: {
+    /**
+     * Checks if all or some of the supplied values are numbers.
+     *
+     * This method uses the `Array.prototype.every` or `Array.prototype.some`
+     * method to check if all or some of the supplied values are numbers,
+     * respectively. The method to use is determined by the `which` parameter.
+     *
+     * @param {string} [which='every'] - Determines the method to use for the
+     * check. Can be either 'every' or 'some'. Defaults to 'every'.
+     * @param {...*} values - The values to check.
+     * @returns {boolean} - Returns `true` if all or some of the values are
+     * numbers (based on the `which` parameter), `false` otherwise.
+     *
+     * @example
+     * areNumbers('every', 1, 2, 3) // true
+     * areNumbers('some', 1, '2', 3) // true
+     * areNumbers('every', 1, '2', 3) // false
+     */
+    areBigInts(which = ['every', 'some'][0], ...values) {
+      if (which !== 'every' && which !== 'some') {
+        return false
+      }
 
-  /**
-   * Conditionally returns a value based on whether the supplied
-   * `value` is a `BigInt` or not. If the `value` is a `BigInt`,
-   * the `thenValue` will be returned. If it is not a `BigInt`,
-   * the `elseValue` will be returned instead.
-   *
-   * @param {any} value The value to check to determine if it is a
-   * `BigInt`
-   * @param {any} thenValue The value to return if the supplied
-   * `value` is a `BigInt`
-   * @param {any} elseValue The value to return if the supplied
-   * `value` is not a `BigInt`
-   * @returns {any} Either the `thenValue` or `elseValue` depending
-   * on if the supplied `value` is a `BigInt`
-   *
-   * @example
-   * const bigInt = 1234567890123456789012345678901234567890n
-   * const num = 42
-   * ifBigInt(bigInt, 'is a BigInt', 'not a BigInt')
-   * // 'is a BigInt'
-   * ifBigInt(num, 'is a BigInt', 'not a BigInt')
-   * // 'not a BigInt'
-   */
-  ifBigInt(value, thenValue, elseValue) {
-    return isThenElse(this.isBigInt(value), thenValue, elseValue)
+      return values[which](num => this.isBigInt(num))
+    },
+
+    /**
+     * Determines if the supplied `value` is a `BigInt`. This check is
+     * performed by first checking the `typeof` the `value` and then
+     * checking to see if the `value` is an `instanceof` `BigInt`
+     *
+     * @param {*} value The value that needs to be checked to determine
+     * if it is a `BigInt` or not
+     * @returns {boolean} `true` if the supplied `value` is a `BigInt`,
+     * `false` otherwise
+     *
+     * @example
+     * const bigInt = 1234567890123456789012345678901234567890n
+     * isBigInt(bigInt) // true
+     * isBigInt(1234567890123456789012345678901234567890) // false
+     * isBigInt('1234567890123456789012345678901234567890') // false
+     * isBigInt(BigInt('1234567890123456789012345678901234567890')) // true
+     */
+    isBigInt(value) {
+      return typeof value === 'bigint' || value instanceof BigInt
+    },
+
+    /**
+     * Conditionally returns a value based on whether the supplied
+     * `value` is a `BigInt` or not. If the `value` is a `BigInt`,
+     * the `thenValue` will be returned. If it is not a `BigInt`,
+     * the `elseValue` will be returned instead.
+     *
+     * @param {any} value The value to check to determine if it is a
+     * `BigInt`
+     * @param {any} thenValue The value to return if the supplied
+     * `value` is a `BigInt`
+     * @param {any} elseValue The value to return if the supplied
+     * `value` is not a `BigInt`
+     * @returns {any} Either the `thenValue` or `elseValue` depending
+     * on if the supplied `value` is a `BigInt`
+     *
+     * @example
+     * const bigInt = 1234567890123456789012345678901234567890n
+     * const num = 42
+     * ifBigInt(bigInt, 'is a BigInt', 'not a BigInt')
+     * // 'is a BigInt'
+     * ifBigInt(num, 'is a BigInt', 'not a BigInt')
+     * // 'not a BigInt'
+     */
+    ifBigInt(value, thenValue, elseValue) {
+      return isThenElse(this.isBigInt(value), thenValue, elseValue)
+    },
+
+    /**
+     * The Math.min() static method returns the smallest of the numbers given
+     * as input parameters, or Infinity if there are no parameters.
+     *
+     * @param {bigint|number} values value1, …, valueN – Zero or more numbers
+     * among which the lowest value will be selected and returned.
+     * @returns {bigint|number|Infinity} The smallest of the given numbers.
+     * Returns Infinity if no parameters are provided.
+     */
+    min(...values) {
+      const sorter = (l,r) => l < r ? -1 : l > r ? 1 : 0
+
+      if (!values.length)
+        return Infinity
+
+      if (values.every(n => typeof n === 'bigint')) {
+        return values.toSorted(sorter).at(0)
+      }
+      else {
+        throw new TypeError('All supplied values must be of type bigint')
+      }
+    },
+
+    /**
+     * The Math.max() static method returns the largest of the numbers given
+     * as input parameters, or Infinity if there are no parameters.
+     *
+     * @param {bigint|number} values value1, …, valueN – Zero or more numbers
+     * among which the largest value will be selected and returned.
+     * @returns {bigint|number|Infinity} The largest of the given numbers.
+     * Returns Infinity if no parameters are provided.
+     */
+    max(...values) {
+      const sorter = (l,r) => l < r ? -1 : l > r ? 1 : 0
+
+      if (!values.length)
+        return Infinity
+
+      if (values.every(n => typeof n === 'bigint')) {
+        return values.toSorted(sorter).at(-1)
+      }
+      else {
+        throw new TypeError('All supplied values must be of type bigint')
+      }
+    },
   },
 })
 
@@ -81,6 +155,36 @@ const { isBigInt: pIsBigInt, ifBigInt: pIfBigInt } = BigIntExtensions.patches
  * // Now the `BigInt` prototype has additional methods available
  */
 export const BigIntPrototypeExtensions = new Patch(BigInt.prototype, {
+  /**
+   * Clamps a value between a minimum and maximum value.
+   *
+   * This method checks if the provided value and the min and max bounds are
+   * numbers. If they are not, it returns the original value. If they are,
+   * it ensures that the value does not go below the minimum value or above
+   * the maximum value.
+   *
+   * @param {bigint} [minValue=BigInt(-Number.MAX_VALUE)] - The minimum value.
+   * Defaults to BigInt(-Number.MAX_VALUE).
+   * @param {bigint} [maxValue=BigInt(Number.MAX_VALUE)] - The maximum value.
+   * Defaults to BigInt(Number.MAX_VALUE).
+   * @returns {bigint} - Returns the clamped value if all parameters are
+   * big integers.
+   *
+   * @example
+   * (10n).clamp(1n, 5n) // returns 5n
+   * (-10n).clamp(1n, 5n) // returns 1n
+   * (3n).clamp(1n, 5n) // returns 3n
+   */
+  clamp(
+    minValue = BigInt(-Number.MAX_VALUE),
+    maxValue = BigInt(Number.MAX_VALUE)
+  ) {
+    if (typeof minValue !== 'bigint' || typeof maxValue !== 'bigint')
+      throw new TypeError('All values must be big integers')
+
+    return BigInt.max(minValue, BigInt.min(maxValue, this))
+  },
+
   /**
    * A getter method that returns an object representation of the BigInt
    * instance.
@@ -149,6 +253,28 @@ export const BigIntPrototypeExtensions = new Patch(BigInt.prototype, {
   ifBigInt(thenValue, elseValue) {
     return pIfBigInt(this, thenValue, elseValue)
   },
+
+  /**
+   * Provides a way when dealing with numbers to determine if
+   * a given number is within a range of values. By default, if
+   * no parameters are supplied, it always returns true since
+   * the default range is -Infinity to +Infinity. Additionally,
+   * by default, the number will always be less than the supplied
+   * max unless inclusive is set to true.
+   *
+   * @param min the lower range value, defaults to -Infinity
+   * @param max the upper range value, defaults to +Infinity
+   * @param inclusive defaults to false, set to true if you
+   * want the max value to less than and equals to
+   * @returns {boolean} true if within the range, false otherwise
+   */
+  within(
+    min = BigInt(-Infinity),
+    max = BigInt(Infinity),
+    inclusive = false
+  ) {
+    return this >= min && (inclusive ? this <= max : this < max)
+  }
 })
 
 // NOTE to self; this is repeated here otherwise a circular reference from