feat!(ensure): remove options from ensure

Now `ensure` does not accept options. Use `@core/errorutil/alter` to
throw a custom error.

Author: lambdalisue

README.md

@@ -211,9 +211,22 @@ const a: unknown = "Hello";
 
 // `ensure` returns `string` or throws an `AssertError`
 const _: string = ensure(a, is.String);
+```
 
-// With custom message
-const __: string = ensure(a, is.String, { message: "a must be a string" });
+Use [`@core/errorutil/alter`](https://jsr.io/@core/errorutil/doc/alter/~/alter)
+to throw a custom error:
+
+```typescript
+import { alter } from "@core/errorutil/alter";
+import { ensure, is } from "@core/unknownutil";
+
+const a: unknown = 0;
+
+// The following throws an Error("a is not a string")
+const _: string = alter(
+  () => ensure(a, is.String),
+  new Error("a is not a string"),
+);
 ```
 
 ### maybe

deno.jsonc

@@ -69,6 +69,7 @@
     ]
   },
   "imports": {
+    "@core/errorutil": "jsr:@core/errorutil@^1.2.0",
     "@core/iterutil": "jsr:@core/iterutil@^0.3.0",
     "@core/unknownutil": "./mod.ts",
     "@deno/dnt": "jsr:@deno/dnt@^0.41.1",

ensure.ts

@@ -6,23 +6,32 @@ import { assert } from "./assert.ts";
  *
  * It throws {@linkcode [assert].AssertError|AssertError} if the value does not satisfy the predicate.
  *
+ * @param x The value to be ensured.
+ * @param pred The predicate function to test the value against.
+ * @returns The input value `x`.
+ *
  * ```ts
  * import { ensure, is } from "@core/unknownutil";
  *
  * const a: unknown = "hello";
  * const _: string = ensure(a, is.String);
  * ```
  *
- * @param x The value to be ensured.
- * @param pred The predicate function to test the value against.
- * @param options Optional configuration for the assertion.
- * @returns The input value `x`.
+ * Use {@linkcode https://jsr.io/@core/errorutil/doc/alter/~/alter|@core/errorutil/alter.alter} to alter error.
+ *
+ * ```ts
+ * import { alter } from "@core/errorutil/alter";
+ * import { ensure, is } from "@core/unknownutil";
+ *
+ * const a: unknown = 42;
+ * const _: string = alter(() => ensure(a, is.String), new Error("a is not a string"));
+ * // Error: a is not a string
+ * ```
  */
 export function ensure<T>(
   x: unknown,
   pred: Predicate<T>,
-  options: { message?: string; name?: string } = {},
 ): T {
-  assert(x, pred, options);
+  assert(x, pred);
   return x;
 }

ensure_test.ts

@@ -1,9 +1,5 @@
 import { assertStrictEquals, assertThrows } from "@std/assert";
-import {
-  AssertError,
-  defaultAssertMessageFactory,
-  setAssertMessageFactory,
-} from "./assert.ts";
+import { AssertError } from "./assert.ts";
 import { ensure } from "./ensure.ts";
 
 const x: unknown = Symbol("x");
@@ -28,40 +24,4 @@ Deno.test("ensure", async (t) => {
       `Expected a value that satisfies the predicate falsePredicate, got symbol: undefined`,
     );
   });
-
-  await t.step(
-    "throws an `AssertError` on false predicate with a custom name",
-    () => {
-      assertThrows(
-        () => ensure(x, falsePredicate, { name: "hello world" }),
-        AssertError,
-        `Expected hello world that satisfies the predicate falsePredicate, got symbol: undefined`,
-      );
-    },
-  );
-
-  await t.step(
-    "throws an `AssertError` with a custom message on false predicate",
-    () => {
-      assertThrows(
-        () => ensure(x, falsePredicate, { message: "Hello" }),
-        AssertError,
-        "Hello",
-      );
-    },
-  );
-});
-
-Deno.test("setAssertMessageFactory", async (t) => {
-  setAssertMessageFactory((x, pred) => `Hello ${typeof x} ${pred.name}`);
-
-  await t.step("change `AssertError` message on `ensure` failure", () => {
-    assertThrows(
-      () => ensure(x, falsePredicate),
-      AssertError,
-      "Hello symbol falsePredicate",
-    );
-  });
-
-  setAssertMessageFactory(defaultAssertMessageFactory);
 });