@bodil/monkey-business 0.3.4 → 0.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bodil/monkey-business",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Let's give JS core types a polish",
   "homepage": "https://codeberg.org/bodil/monkey-business",
   "repository": {
@@ -20,6 +20,36 @@
         "types": "./dist/index.d.ts",
         "import": "./dist/index.js"
       }
+    },
+    "./array": {
+      "import": {
+        "types": "./dist/array.d.ts",
+        "import": "./dist/array.js"
+      }
+    },
+    "./iterator": {
+      "import": {
+        "types": "./dist/iterator.d.ts",
+        "import": "./dist/iterator.js"
+      }
+    },
+    "./map": {
+      "import": {
+        "types": "./dist/map.d.ts",
+        "import": "./dist/map.js"
+      }
+    },
+    "./object": {
+      "import": {
+        "types": "./dist/object.d.ts",
+        "import": "./dist/object.js"
+      }
+    },
+    "./weakmap": {
+      "import": {
+        "types": "./dist/weakmap.d.ts",
+        "import": "./dist/weakmap.js"
+      }
     }
   },
   "publishConfig": {
@@ -37,22 +67,44 @@
     "@bodil/opt-vitest": "^1.1.0",
     "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
-    "@typescript-eslint/eslint-plugin": "^8.69.0",
-    "@typescript-eslint/parser": "^8.69.0",
+    "@ianvs/prettier-plugin-sort-imports": "^4.7.1",
+    "@typescript-eslint/eslint-plugin": "^8.72.2",
+    "@typescript-eslint/parser": "^8.72.2",
     "@typhonjs-typedoc/ts-lib-docs": "^2024.12.25",
-    "eslint": "^10.10.0",
+    "eslint": "^10.14.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-jsdoc": "^64.3.5",
-    "globals": "^17.12.0",
-    "npm-run-all2": "^9.0.3",
-    "prettier": "^3.9.6",
+    "eslint-plugin-jsdoc": "^64.5.4",
+    "globals": "^17.14.0",
+    "npm-run-all2": "^9.0.4",
+    "prettier": "^3.9.10",
     "typedoc": "^0.28.20",
     "typedoc-plugin-extras": "^4.0.1",
     "typedoc-plugin-mdn-links": "^5.1.1",
     "typedoc-theme-fresh": "^0.2.3",
     "typescript": "^6.0.3",
-    "vite": "^7.3.6",
-    "vitest": "^4.1.11"
+    "vite": "^7.3.8",
+    "vitest": "^4.1.12"
+  },
+  "prettier": {
+    "editorconfig": true,
+    "plugins": [
+      "@ianvs/prettier-plugin-sort-imports"
+    ],
+    "importOrderParserPlugins": [
+      "typescript",
+      "decorators"
+    ],
+    "importOrderTypeScriptVersion": "5.0.0",
+    "importOrder": [
+      "",
+      "<BUILTIN_MODULES>",
+      "",
+      "<THIRD_PARTY_MODULES>",
+      "",
+      "^[.](?!.*[?]inline$)",
+      "",
+      "[?]inline$"
+    ]
   },
   "scripts": {
     "build": "tsc",
@@ -62,6 +114,6 @@
     "check": "run-p check:tsc check:eslint",
     "doc": "typedoc",
     "doc:readthedocs": "typedoc --out $READTHEDOCS_OUTPUT/html",
-    "prepublish": "tsc"
+    "prepublish": "rm -rf dist && run-p check test build"
   }
 }

package/src/array.ts

@@ -0,0 +1,128 @@
+import { bisectHigh, bisectLow, type OrderFn } from "@bodil/core/order";
+import type { Present } from "@bodil/core/types";
+import { None, Option, type Some } from "@bodil/opt";
+
+import { get as objectGet } from "./object";
+
+/**
+ * Insert `value` at `index` in the array.
+ */
+export function insert<T>(this: Array<T>, value: T, index: number): Array<T> {
+    if (!Number.isInteger(index)) {
+        throw new TypeError(`Array.insert(): index ${index} is not an integer`);
+    }
+    if (index > this.length || index < 0) {
+        throw new RangeError(`Array.insert: index ${index} out of bounds`);
+    }
+    this.splice(index, 0, value);
+    return this;
+}
+
+/**
+ * Insert `value` into the array at the correct position according to
+ * the ordering function `cmp`. The array must already be ordered
+ * accordingly.
+ *
+ * If `duplicates` is `"low"`, the correct position in case of
+ * duplicates is considered to be the index of the first occurrence of a
+ * duplicate. If it is `"high"`, which is the default, the correct
+ * position is considered to be the index after the last occurrence of a
+ * duplicate.
+ */
+export function insertOrdered<T>(
+    this: Array<T>,
+    value: T,
+    cmp: OrderFn<T>,
+    duplicates: "low" | "high" = "high",
+): Array<T> {
+    return (insert<T>).call(
+        this,
+        value,
+        (duplicates === "low" ? bisectLow : bisectHigh)(cmp, this, value),
+    );
+}
+
+/**
+ * Remove the first occurrence of a given value from an array.
+ *
+ * Returns an {@link Option} containing the removed value, or {@link None} if
+ * no matches were found.
+ */
+export function remove<T>(this: Array<T>, value: T): Option<T> {
+    return (removeIndex<T>).call(this, this.indexOf(value));
+}
+
+/**
+ * Remove the first value for which the provided predicate function
+ * returns `true` from the array.
+ *
+ * Returns an {@link Option} containing the removed value, or {@link None} if
+ * no matches were found.
+ */
+export function removeFn<T>(
+    this: Array<T>,
+    predicate: (value: T, index: number, obj: Array<T>) => boolean,
+): Option<T> {
+    return (removeIndex<T>).call(this, this.findIndex(predicate));
+}
+
+/**
+ * Remove the value at the given index from the array.
+ *
+ * Returns an {@link Option} containing the removed value, or {@link None} if
+ * the index was out of bounds.
+ */
+export function removeIndex<T>(this: Array<T>, index: number): Option<T> {
+    if (!Number.isInteger(index)) {
+        throw new TypeError(`Array.removeIndex(): index ${index} is not an integer`);
+    }
+    if (index < 0 || index >= this.length) {
+        return None;
+    }
+    const removed = this.splice(index, 1).pop();
+    return Option.from(removed);
+}
+
+/**
+ * Return a copy of the array with any `undefined` values removed.
+ */
+export function present<T>(this: Array<T>): Array<Present<T>> {
+    return this.filter((value: T): value is Present<T> => value !== undefined);
+}
+
+/**
+ * Return a copy of the array with any `null` or `undefined` values removed.
+ */
+export function nonNullable<T>(this: Array<T>): Array<NonNullable<T>> {
+    return this.filter(
+        (value: T): value is NonNullable<T> => value !== undefined && value !== null,
+    );
+}
+
+/**
+ * Checked index operator. Returns {@link None} if an index isn't
+ * present, even for sparse arrays. Returns a {@link Some} if the index
+ * is present, even if the value is `undefined`.
+ */
+export function get<T>(this: Array<T>, index: number): Option<T> {
+    return objectGet(this, index);
+}
+
+/**
+ * Test whether a value is an array with the same contents as this one.
+ */
+export function equals<T, U = unknown>(
+    this: Array<T>,
+    other: unknown,
+    equalsFn: (a: T, b: U) => boolean = Object.is,
+): other is Array<T> {
+    if (!Array.isArray(other) || this.length !== other.length) {
+        return false;
+    }
+    for (let index = 0; index < this.length; index++) {
+        if (!equalsFn(this[index], other[index])) {
+            return false;
+        }
+    }
+    return true;
+}

package/src/es-iterator-helpers.d.ts

@@ -0,0 +1,24 @@
+declare module "es-iterator-helpers/Iterator.concat/polyfill" {
+    function getPolyfill(): <T>(...inputs: Array<Iterable<T>>) => IteratorObject<T>;
+    export default getPolyfill;
+}
+
+declare module "es-iterator-helpers/Iterator.zip/polyfill" {
+    function getPolyfill(): <T>(inputs: Iterable<Iterable<T>>) => IteratorObject<Array<T>>;
+    export default getPolyfill;
+}
+
+declare module "es-iterator-helpers/Iterator.zipKeyed/polyfill" {
+    function getPolyfill(): <T>(
+        inputs: Record<string, Iterable<T>>,
+    ) => IteratorObject<Record<string, T>>;
+    export default getPolyfill;
+}
+
+declare module "es-iterator-helpers/Iterator.prototype.chunks/polyfill" {
+    function getPolyfill(): <T>(
+        this: Iterator<T>,
+        size: number,
+    ) => IteratorObject<Array<T>, undefined>;
+    export default getPolyfill;
+}

package/src/index.test.ts

@@ -1,9 +1,8 @@
-import { test, expect, expectTypeOf } from "vitest";
-import type { Option } from "@bodil/opt";
 import { order as Order } from "@bodil/core";
+import type { Option } from "@bodil/opt";
+import { expect, expectTypeOf, test } from "vitest";
 
 import ".";
-
 import "@bodil/opt-vitest";
 
 const Iterator = globalThis.Iterator;
@@ -52,6 +51,22 @@ test("Map.getOrSet", () => {
     expect(map.getOrInsertComputed("bar", defaultValue)).toEqual("Robert");
     expect(map.getOrInsertComputed("Mike", defaultValueCat)).toEqual("RobertMike");
     expect(map.get("bar")).toEqual("Robert");
+    expect(map.getOrSet("foo", defaultValue)).toEqual("Joe");
+    expect(map.getOrSet("baz", defaultValue)).toEqual("Robert");
+    expect(map.get("baz")).toEqual("Robert");
+});
+
+test("WeakMap.getOrSet", () => {
+    const defaultValue = () => "Robert";
+    const weakmap = new WeakMap();
+    const foo = {};
+    const bar = {};
+    weakmap.set(foo, "Joe");
+    expect(weakmap.getOrInsertComputed(foo, defaultValue)).toEqual("Joe");
+    expect(weakmap.getOrInsertComputed(bar, defaultValue)).toEqual("Robert");
+    expect(weakmap.getOrSet(foo, defaultValue)).toEqual("Joe");
+    expect(weakmap.getOrSet(bar, defaultValue)).toEqual("Robert");
+    expect(weakmap.get(bar)).toEqual("Robert");
 });
 
 test("Map.remove", () => {
@@ -102,6 +117,14 @@ test("Array.filterPresent", () => {
     expectTypeOf(cleanArray).toExtend<Array<number>>();
 });
 
+test("Array.filterNonNullable", () => {
+    const array: Array<number | null | undefined> = [1, null, 2, undefined, 3, null, 4];
+    const cleanArray = array.nonNullable();
+    expect(cleanArray.some((v) => v === undefined || v === null)).toBeFalsy();
+    expect(cleanArray).toEqual([1, 2, 3, 4]);
+    expectTypeOf(cleanArray).toExtend<Array<number>>();
+});
+
 test("Iterator.chunks", () => {
     expect(Array.from(Iterator.from([1, 2, 3, 4]).chunks(2))).toEqual([
         [1, 2],
@@ -112,12 +135,12 @@ test("Iterator.chunks", () => {
 });
 
 test("Iterator.partition", () => {
-    expect(Array.from(Iterator.from([1, 2, 3, 4]).partition(2))).toEqual([
+    expect(Array.from(Iterator.from([1, 2, 3, 4]).chunks(2))).toEqual([
         [1, 2],
         [3, 4],
     ]);
 
-    expect(Array.from(Iterator.from([1, 2, 3]).partition(2))).toEqual([[1, 2], [3]]);
+    expect(Array.from(Iterator.from([1, 2, 3]).chunks(2))).toEqual([[1, 2], [3]]);
 });
 
 test("Iterator.frontBiasedPartition", () => {
@@ -170,8 +193,8 @@ test("Iterator.equals", () => {
     expect(
         Iterator.from([1, 2, 3]).equals(
             ["1", "2", "3"],
-            (a: number, b: string) => a.toString() === b
-        )
+            (a: number, b: string) => a.toString() === b,
+        ),
     ).toBeTruthy();
 });