@tim-code/my-util 0.6.3 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tim-code/my-util",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "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/array.js

@@ -176,9 +176,30 @@ export function descending(transform) {
   }
 }
 
+function compareUndefinedNullEmpty(a, b) {
+  if (b === undefined || b === null || b === "") {
+    if (a === undefined || a === null || a === "") {
+      return 0
+    }
+    return -1
+  } else if (a === undefined || a === null || a === "") {
+    return 1
+  }
+  return undefined
+}
+
+function naturalCompare(a, b) {
+  if (a[0] === "-" && b[0] === "-") {
+    a = a.slice(1, a.length)
+    b = b.slice(1, b.length)
+    return b.localeCompare(a, undefined, { numeric: true })
+  }
+  return a.localeCompare(b, undefined, { numeric: true })
+}
+
 /**
  * Returns an "ascending" comparator using natural string sort, to be used to sort an array of strings.
- * Undefined or null values are always sorted to the end.
+ * Empty string or undefined or null values are always sorted to the end.
  * @param {string|number|Function=} transform
  *  If a function, calls the provided function on an element to get the value to sort on.
  *  If a string or number, treats transform as a key and sorts on each element's value at key.
@@ -189,22 +210,22 @@ export function naturalAsc(transform) {
     return (a, b) => {
       a = transform(a)
       b = transform(b)
-      return compareUndefinedNull(a, b) ?? a.localeCompare(b, undefined, { numeric: true })
+      return compareUndefinedNullEmpty(a, b) ?? naturalCompare(a, b)
     }
   }
   if (typeof transform === "string" || typeof transform === "number") {
     return (a, b) => {
-      const invalid = compareUndefinedNull(a[transform], b[transform])
-      return invalid ?? a[transform].localeCompare(b[transform], undefined, { numeric: true })
+      const invalid = compareUndefinedNullEmpty(a[transform], b[transform])
+      return invalid ?? naturalCompare(a[transform], b[transform])
     }
   }
   return (a, b) => {
-    return compareUndefinedNull(a, b) ?? a.localeCompare(b, undefined, { numeric: true })
+    return compareUndefinedNullEmpty(a, b) ?? naturalCompare(a, b)
   }
 }
 /**
  * Returns a "descending" comparator using natural string sort, to be used to sort an array of strings.
- * Undefined or null values are always sorted to the end.
+ * Empty string or undefined or null values are always sorted to the end.
  * @param {string|number|Function=} transform
  *  If a function, calls the provided function on an element to get the value to sort on.
  *  If a string or number, treats transform as a key and sorts on each element's value at key.
@@ -215,17 +236,17 @@ export function naturalDesc(transform) {
     return (a, b) => {
       b = transform(b)
       a = transform(a)
-      return compareUndefinedNull(a, b) ?? b.localeCompare(a, undefined, { numeric: true })
+      return compareUndefinedNullEmpty(a, b) ?? naturalCompare(b, a)
     }
   }
   if (typeof transform === "string" || typeof transform === "number") {
     return (a, b) => {
-      const invalid = compareUndefinedNull(a[transform], b[transform])
-      return invalid ?? b[transform].localeCompare(a[transform], undefined, { numeric: true })
+      const invalid = compareUndefinedNullEmpty(a[transform], b[transform])
+      return invalid ?? naturalCompare(b[transform], a[transform])
     }
   }
   return (a, b) => {
-    return compareUndefinedNull(a, b) ?? b.localeCompare(a, undefined, { numeric: true })
+    return compareUndefinedNullEmpty(a, b) ?? naturalCompare(b, a)
   }
 }
 

package/src/array.test.js

@@ -511,12 +511,24 @@ describe("naturalAsc", () => {
     expect(arr.map((o) => o.v)).toEqual(["file1", "file2", "file10", undefined, null])
   })
 
+  it("defers empty string to the end along with undefined/null (default path)", () => {
+    const arr = ["b", "", "a", undefined, null, "c"]
+    arr.sort(naturalAsc())
+    expect(arr).toEqual(["a", "b", "c", "", null, undefined])
+  })
+
+  it("defers empty string to the end along with undefined/null (key path)", () => {
+    const arr = [{ v: "" }, { v: "a2" }, { v: undefined }, { v: "a1" }, { v: null }]
+    arr.sort(naturalAsc("v"))
+    expect(arr.map((o) => o.v)).toEqual(["a1", "a2", "", undefined, null])
+  })
+
   it("returns 0 for equal values (function and key paths)", () => {
     expect(naturalAsc((x) => x)("a", "a")).toBe(0)
     expect(naturalAsc("v")({ v: "x" }, { v: "x" })).toBe(0)
   })
 
-  it("default comparator sorts with undefined/null at end but uses non-natural, descending semantics", () => {
+  it("default comparator sorts naturally with undefined/null at end", () => {
     const arr = [undefined, "b", null, "a", "c"]
     arr.sort(naturalAsc())
     expect(arr).toEqual(["a", "b", "c", null, undefined])
@@ -524,6 +536,12 @@ describe("naturalAsc", () => {
     numericLike.sort(naturalAsc())
     expect(numericLike).toEqual(["a1", "a2", "a10"])
   })
+
+  it("handles negative number-like strings by comparing magnitudes (both negative)", () => {
+    const arr = ["-2", "-10", "-1"]
+    arr.sort(naturalAsc())
+    expect(arr).toEqual(["-10", "-2", "-1"])
+  })
 })
 
 describe("naturalDesc", () => {
@@ -551,10 +569,23 @@ describe("naturalDesc", () => {
     expect(arr.map((o) => o.v)).toEqual(["file10", "file2", "file1", undefined, null])
   })
 
+  it("defers empty string to the end along with undefined/null (default path)", () => {
+    const arr = ["b", "", "a", undefined, null, "c"]
+    arr.sort(naturalDesc())
+    expect(arr.slice(-3)).toEqual(["", null, undefined])
+    expect(arr.slice(0, 3)).toEqual(["c", "b", "a"])
+  })
+
   it("returns 0 for equal values (function and key paths)", () => {
     expect(naturalDesc((x) => x)("a", "a")).toBe(0)
     expect(naturalDesc("v")({ v: "x" }, { v: "x" })).toBe(0)
   })
+
+  it("handles negative number-like strings by comparing magnitudes (both negative) in descending", () => {
+    const arr = ["-2", "-10", "-1"]
+    arr.sort(naturalDesc())
+    expect(arr).toEqual(["-1", "-2", "-10"])
+  })
 })
 
 describe("multilevel", () => {

package/src/math.js

@@ -176,7 +176,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/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]
     }