feat: add const type parameter to isLiteralOneOf

Enable literal type inference without 'as const' assertion by using
TypeScript 5.0+ const type parameters. This maintains full backward
compatibility while improving developer experience.

Author: lambdalisue

deno.jsonc

@@ -4,6 +4,11 @@
   "compilerOptions": {
     "exactOptionalPropertyTypes": true
   },
+  "lint": {
+    "rules": {
+      "exclude": ["no-import-prefix"]
+    }
+  },
   "exports": {
     ".": "./mod.ts",
     "./as": "./as/mod.ts",

is/literal_one_of.ts

@@ -12,14 +12,14 @@ import type { Predicate, Primitive } from "../type.ts";
  * ```ts
  * import { is } from "@core/unknownutil";
  *
- * const isMyType = is.LiteralOneOf(["hello", "world"] as const);
+ * const isMyType = is.LiteralOneOf(["hello", "world"]);
  * const a: unknown = "hello";
  * if (isMyType(a)) {
  *   const _: "hello" | "world" = a;
  * }
  * ```
  */
-export function isLiteralOneOf<T extends readonly Primitive[]>(
+export function isLiteralOneOf<const T extends readonly Primitive[]>(
   literals: T,
 ): Predicate<T[number]> {
   const s = new Set(literals);

is/literal_one_of_test.ts

@@ -28,4 +28,16 @@ Deno.test("isLiteralOneOf<T>", async (t) => {
       assertType<IsExact<typeof a, "hello" | "world">>(true);
     }
   });
+
+  await t.step("works without as const assertion", () => {
+    const predicate = isLiteralOneOf(["foo", "bar"]);
+    assertEquals(predicate("foo"), true);
+    assertEquals(predicate("bar"), true);
+    assertEquals(predicate("baz"), false);
+
+    const b: unknown = "foo";
+    if (predicate(b)) {
+      assertType<IsExact<typeof b, "foo" | "bar">>(true);
+    }
+  });
 });