@tim-code/my-util 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "",
   "type": "module",
   "author": "Tim Sprowl",
@@ -23,7 +23,7 @@
   },
   "devDependencies": {
     "@jest/globals": "^30.2.0",
-    "@tim-code/eslint-config": "^2.0.1",
+    "@tim-code/eslint-config": "^2.1.0",
     "jest": "^30.2.0"
   },
   "jest": {

package/src/math.js

@@ -144,6 +144,24 @@ export function range(start, end, increment = 1) {
   return results
 }
 
+/**
+ * Create an array of numbers progressing from start up to and including end.
+ * @param {number} start
+ * @param {number=} end
+ * @param {number=} increment
+ * @returns {number[]}
+ */
+export function between(start, end, increment = 1) {
+  if (!(increment > 0)) {
+    return []
+  }
+  const results = []
+  for (let i = start; i <= end; i += increment) {
+    results.push(i)
+  }
+  return results
+}
+
 /**
  * Check if the argument is a number.
  * This excludes Infinity and NaN, but otherwise is equivalent to `typeof number === "number"`.
@@ -176,7 +194,7 @@ export function quantiles(array, { N, key, method = Math.round, labeller = Math.
     return undefined
   }
   const sorted = [...array].sort(ascending(key))
-  const result = {}
+  const result = Object.create(null)
   for (let i = 0; i <= N; i++) {
     const percentile = i / N
     const percentileIndex = method(percentile * (sorted.length - 1))

package/src/math.test.js

@@ -1,4 +1,5 @@
 import { describe, expect, it } from "@jest/globals"
+import { between } from "./math.js"
 
 // EXPORTED FUNCTIONS UNDER TEST:
 // - mod
@@ -314,6 +315,52 @@ describe("range", () => {
   })
 })
 
+describe("between", () => {
+  it("returns an empty array if start >= end", () => {
+    expect(between(7, 5)).toEqual([])
+    expect(between(10, 5)).toEqual([])
+
+    expect(between(5, 5)).toEqual([5])
+  })
+
+  it("returns a sequence from start to end with default increment 1", () => {
+    expect(between(0, 3)).toEqual([0, 1, 2, 3])
+    expect(between(2, 6)).toEqual([2, 3, 4, 5, 6])
+  })
+
+  it("returns a sequence with a custom positive increment", () => {
+    expect(between(0, 5, 2)).toEqual([0, 2, 4])
+    expect(between(1, 8, 3)).toEqual([1, 4, 7])
+  })
+  it("works with negative start and end", () => {
+    expect(between(-3, 1)).toEqual([-3, -2, -1, 0, 1])
+    expect(between(-5, -2)).toEqual([-5, -4, -3, -2])
+  })
+
+  it("returns an empty array if increment is zero", () => {
+    expect(between(0, 5, 0)).toEqual([])
+  })
+
+  it("returns an empty array if increment is negative and start < end", () => {
+    expect(between(0, 5, -1)).toEqual([])
+    expect(between(2, 6, -2)).toEqual([])
+  })
+
+  it("returns an empty array if increment is negative and start > end", () => {
+    expect(between(5, 0, -1)).toEqual([])
+    expect(between(3, -2, -2)).toEqual([])
+  })
+
+  it("returns an empty array if increment is positive and start > end", () => {
+    expect(between(5, 0, 1)).toEqual([])
+    expect(between(2, -2, 2)).toEqual([])
+  })
+
+  it("handles floating point increments", () => {
+    expect(between(0, 1, 0.25)).toEqual([0, 0.25, 0.5, 0.75, 1])
+  })
+})
+
 describe("isNumber", () => {
   it("returns true for finite numbers", () => {
     expect(isNumber(0)).toBe(true)

package/src/object.js

@@ -15,7 +15,7 @@ export function isObject(thing) {
  * @returns {Object}
  */
 export function mapValues(object, callback) {
-  const result = {}
+  const result = Object.create(null)
   const keys = Object.keys(object)
   for (const key of keys) {
     result[key] = callback(object[key], key, object)

package/src/run.js

@@ -10,7 +10,7 @@ import { pathToFileURL } from "url"
 export function runnable(importMetaUrl, args, callback) {
   if (importMetaUrl === pathToFileURL(process.argv[1]).href) {
     // module was not imported but called directly
-    const parameter = {}
+    const parameter = Object.create(null)
     for (let i = 0; i < args.length; i++) {
       parameter[args[i]] = process.argv[i + 2]
     }