request() の戻り値により 戻り型は 確定する対応

src/lock.test.ts

@@ -13,7 +13,6 @@ describe("simple use", () => {
       {
         await using l = await request();
         expect(l).toBeDefined();
-        if (!l) return;
         expect(l.name).toEqual(name);
         expect(l.mode).toEqual("exclusive");
         expect(l.release).instanceOf(Function);
@@ -46,7 +45,6 @@ describe("simple use", () => {
           mode: "exclusive",
         });
         expect(lock1).toBeDefined();
-        if (!lock1) return;
         expect(counter++).toEqual(0);
         await expect(query()).resolves.toEqual({
           held: [
@@ -82,7 +80,6 @@ describe("simple use", () => {
         await lock1.release();
         await using lock2 = await lock2Wait;
         expect(lock2).toBeDefined();
-        if (!lock2) return;
         expect(lock2.name).toBeDefined();
         expect(counter++).toEqual(3);
       }
@@ -101,13 +98,11 @@ describe("simple use", () => {
           mode: "shared",
         });
         expect(lock1).toBeDefined();
-        if (!lock1) return;
         await expect(query()).resolves.toHaveProperty("held");
         await using lock2 = await request({
           mode: "shared",
         });
         expect(lock2).toBeDefined();
-        if (!lock2) return;
         expect(lock2.name).toBe(name);
         const lock3Wait = request({
           mode: "exclusive",
@@ -148,7 +143,6 @@ describe("simple use", () => {
         });
         await using lock3 = await lock3Wait;
         expect(lock3).toBeDefined();
-        if (!lock3) return;
         expect(lock3.name).toBe(name);
         await expect(query()).resolves.toEqual({
           held: [
@@ -197,13 +191,11 @@ describe("simple use", () => {
       {
         await using lock1 = await request();
         expect(lock1).toBeDefined();
-        if (!lock1) return;
         const lock2Wait = request();
         await using lock3 = await request({
           steal: true,
         });
         expect(lock3).toBeDefined();
-        if(!lock3) return;
         expect(lock3.name).toBe(name);
         await expect(lock1.release()).resolves.toBe(false);
         await expect(lock3.release()).resolves.toBe(true);

src/lock.ts

@@ -1,6 +1,6 @@
-import type { InnerLock } from "./types/index.ts";
+import type { InnerLock, ReleasableLock } from "./types/index.ts";
 import { query } from "./query.js";
-import { request } from "./request.js";
+import { request as originalRequest } from "./request.js";
 
 /**
  * Creates a simple lock handler for the specified `name`.
@@ -22,8 +22,12 @@ export function lock(name: string, options?: { locks?: LockManager }) {
     throw new Error("navigator.locks is not found. required options.locks argument.");
   }
   const thisArgs: InnerLock = { locks, name };
+  const request = originalRequest.bind(thisArgs) as {
+    (options: Omit<LockOptions, "ifAvailable"> & { ifAvailable: true }): Promise<ReleasableLock | null>;
+    (options?: Omit<LockOptions, "ifAvailable"> & { ifAvailable?: false }): Promise<ReleasableLock>;
+  };
   return {
-    request: request.bind(thisArgs),
+    request,
     query: query.bind(thisArgs),
   };
 }

src/request.ts

@@ -14,7 +14,9 @@ import type { InnerLock, ReleasableLock } from "./types/index.ts";
  * @param options - LockOptions (mode, ifAvailable, steal, signal, etc.)
  * @returns A promise that resolves to either a ReleasableLock or a NotHaveLock.
  */
-export async function request(this: InnerLock, options?: LockOptions): Promise<ReleasableLock|null> {
+export async function request(this: InnerLock, options: Omit<LockOptions, "ifAvailable"> & { ifAvailable: true }): Promise<ReleasableLock | null>;
+export async function request(this: InnerLock, options?: Omit<LockOptions, "ifAvailable"> & { ifAvailable?: false }): Promise<ReleasableLock>;
+export async function request(this: InnerLock, options?: LockOptions): Promise<ReleasableLock | null> {
   // #region Create resolvers to coordinate async lock lifecycle
 
   // case1: called callback