refactor(websocket): Use Result from npm:option-t

browser/websocket/push.ts

@@ -5,7 +5,6 @@ import {
   type PageCommitError,
   type PageCommitResponse,
   type PinChange,
-  type Result as SocketResult,
   type Socket,
   socketIO,
   type TimeoutError,
@@ -26,6 +25,7 @@ import {
   createOk,
   isErr,
   type Result,
+  unwrapErr,
   unwrapOk,
 } from "option-t/plain_result";
 import type { HTTPError } from "../../rest/responseIntoResult.ts";
@@ -133,19 +133,20 @@ export const push = async (
         const result = (await request("socket.io-request", {
           method: "commit",
           data,
-        })) as SocketResult<
+        })) as Result<
           PageCommitResponse,
           UnexpectedError | TimeoutError | PageCommitError
         >;
 
-        if (result.ok) {
-          metadata.commitId = result.value.commitId;
+        if (createOk(result)) {
+          metadata.commitId = unwrapOk(result).commitId;
           // success
           return createOk(metadata.commitId);
         }
-        const name = result.value.name;
+        const error = unwrapErr(result);
+        const name = error.name;
         if (name === "UnexpectedError") {
-          return createErr({ name, message: JSON.stringify(result.value) });
+          return createErr({ name, message: JSON.stringify(error) });
         }
         if (name === "TimeoutError" || name === "SocketIOError") {
           await delay(3000);

browser/websocket/websocket-types.ts

@@ -152,10 +152,6 @@ const pageCommitErrorNames = [
   "NotFastForwardError",
 ];
 
-export type Result<T, E = unknown> =
-  | { ok: true; value: T }
-  | { ok: false; value: E };
-
 export interface EventMap {
   "socket.io-request": (
     req: { method: "commit"; data: PageCommit } | {

browser/websocket/wrap.ts

@@ -1,11 +1,11 @@
+import { createErr, createOk, type Result } from "option-t/plain_result";
 import type { Socket } from "./socket-io.ts";
 import {
   type DataOf,
   type EventMap,
   type FailedResOf,
   isPageCommitError,
   type ListenEventMap,
-  type Result,
   type SuccessResOf,
   type TimeoutError,
   type UnexpectedError,
@@ -62,25 +62,23 @@ export const wrap = (
                   typeof response.error.name === "string" &&
                   isPageCommitError({ name: response.error.name })
                 ) {
-                  resolve({ ok: false, value: response.error });
+                  resolve(createErr(response.error));
                 } else {
-                  resolve({
-                    ok: false,
-                    value: { name: "UnexpectedError", value: response.error },
-                  });
+                  resolve(
+                    createErr(unexpectedError(response.error)),
+                  );
                 }
               } else if ("data" in response) {
-                resolve({ ok: true, value: response.data });
+                resolve(createOk(response.data));
               }
               break;
             case "cursor":
               if ("error" in response) {
-                resolve({
-                  ok: false,
-                  value: { name: "UnexpectedError", value: response.error },
-                });
+                resolve(
+                  createErr(unexpectedError(response.error)),
+                );
               } else if ("data" in response) {
-                resolve({ ok: true, value: response.data });
+                resolve(createOk(response.data));
               }
               break;
           }
@@ -93,13 +91,12 @@ export const wrap = (
       );
       id = setTimeout(() => {
         socket.off("disconnect", onDisconnect);
-        resolve({
-          ok: false,
-          value: {
+        resolve(
+          createErr({
             name: "TimeoutError",
             message: `Timeout: exceeded ${timeout}ms`,
-          },
-        });
+          }),
+        );
       }, timeout);
       socket.once("disconnect", onDisconnect);
     });
@@ -135,3 +132,8 @@ export const wrap = (
 
   return { request, response };
 };
+
+const unexpectedError = (value: unknown): UnexpectedError => ({
+  name: "UnexpectedError",
+  value,
+});