@tempoxyz/id 0.0.0-pr-748.sha-9ca4b35 → 0.0.0-pr-670.sha-e9b244c

package/dist/{Connections-XQEOD6XM.js → Connections-4J63W3O3.js}

@@ -4,9 +4,9 @@ import {
   name,
   parseName,
   pending
-} from "./chunk-HGF2MYA7.js";
-import "./chunk-AUGJ5ANC.js";
-import "./chunk-YW5DUQT3.js";
+} from "./chunk-QL7UYVGP.js";
+import "./chunk-HWONYWNC.js";
+import "./chunk-2BJJYAAI.js";
 import "./chunk-MLKGABMK.js";
 export {
   attach,

package/dist/Server-GHH2TOPL.js

@@ -0,0 +1,335 @@
+import {
+  basePath,
+  from
+} from "./chunk-HWONYWNC.js";
+import {
+  PendingNotFoundError,
+  RequestError
+} from "./chunk-2BJJYAAI.js";
+import "./chunk-MLKGABMK.js";
+
+// ../../accounts/src/internal/BackendCookie.ts
+var names = {
+  /** Present while a sign-in that the dialog started is in progress, for 10 minutes. */
+  dialog: "__Host-tempo-id.dialog",
+  /** The session ID of a sign-in in progress, for 10 minutes. */
+  pending: "__Host-tempo-id.pending",
+  /** The app's path to return to after the sign-in, for 10 minutes. */
+  return: "__Host-tempo-id.return",
+  /** The session ID. */
+  session: "__Host-tempo-id.sid"
+};
+function get(request, options) {
+  const header = request.headers.get("cookie");
+  if (!header) return void 0;
+  for (const part of header.split(";")) {
+    const index = part.indexOf("=");
+    if (index < 0) continue;
+    if (part.slice(0, index).trim() !== options.name) continue;
+    const value = part.slice(index + 1).trim();
+    return value || void 0;
+  }
+  return void 0;
+}
+function serialize(options) {
+  const { maxAge, name, value } = options;
+  const attributes = ["Path=/", "HttpOnly", "Secure", "SameSite=Lax"];
+  if (value === void 0) attributes.push("Max-Age=0");
+  else if (maxAge !== void 0) attributes.push(`Max-Age=${maxAge}`);
+  return [`${name}=${value ?? ""}`, ...attributes].join("; ");
+}
+
+// ../../accounts/src/internal/handlers/Backend.ts
+var pendingMaxAge = 10 * 60;
+var relayScript = `(() => {
+  const url = new URL(location.href)
+  const state = url.searchParams.getAll('state').at(-1)
+  if (state) {
+    const channel = new BroadcastChannel('tempo-id:dialog:' + state)
+    channel.postMessage({ url: url.href })
+    channel.close()
+  }
+  window.close()
+})()`;
+function create(options) {
+  const { backend } = options;
+  const base = (options.basePath ?? "").replace(/\/+$/, "");
+  function redirectUri(request) {
+    return options.redirectUri ?? `${new URL(request.url).origin}${base}/callback`;
+  }
+  async function login(request) {
+    const url = new URL(request.url);
+    const { id, url: location } = await backend.start({
+      redirectUri: redirectUri(request)
+    });
+    const headers = new Headers({ location });
+    headers.append(
+      "set-cookie",
+      serialize({
+        maxAge: pendingMaxAge,
+        name: names.pending,
+        value: id
+      })
+    );
+    headers.append(
+      "set-cookie",
+      serialize({
+        maxAge: pendingMaxAge,
+        name: names.return,
+        value: encodeURIComponent(
+          returnTo(url.searchParams.get("returnTo"), { origin: url.origin })
+        )
+      })
+    );
+    headers.append(
+      "set-cookie",
+      serialize({ name: names.dialog })
+    );
+    return new Response(null, { headers, status: 302 });
+  }
+  async function dialogLogin(request) {
+    const refusal = foreign(request);
+    if (refusal) return refusal;
+    const { id, url } = await backend.start({
+      display: "popup",
+      par: false,
+      redirectUri: redirectUri(request)
+    });
+    const headers = new Headers({ "cache-control": "no-store" });
+    headers.append(
+      "set-cookie",
+      serialize({
+        maxAge: pendingMaxAge,
+        name: names.pending,
+        value: id
+      })
+    );
+    headers.append(
+      "set-cookie",
+      serialize({
+        maxAge: pendingMaxAge,
+        name: names.dialog,
+        value: "1"
+      })
+    );
+    return Response.json({ url }, { headers });
+  }
+  async function callback(request) {
+    if (get(request, { name: names.dialog }))
+      return relay();
+    const url = new URL(request.url);
+    const path = returnTo(
+      decode(get(request, { name: names.return })),
+      { origin: url.origin }
+    );
+    const headers = cleared();
+    const result = await complete(request, { url: request.url });
+    if ("error" in result) {
+      headers.set(
+        "location",
+        withError(path, { error: result.error, origin: url.origin })
+      );
+      return new Response(null, { headers, status: 302 });
+    }
+    headers.set("location", path);
+    headers.append(
+      "set-cookie",
+      serialize({
+        name: names.session,
+        value: result.id
+      })
+    );
+    return new Response(null, { headers, status: 302 });
+  }
+  async function dialogCallback(request) {
+    const refusal = foreign(request);
+    if (refusal) return refusal;
+    const body = await request.json().catch(() => void 0);
+    const url = typeof body?.url === "string" ? URL.parse(body.url) : null;
+    if (!url)
+      return Response.json(
+        {
+          error: "invalid_request",
+          error_description: "Invalid body: `url` is not a URL. Send the callback URL of the sign-in as `url`."
+        },
+        { status: 400 }
+      );
+    const headers = cleared();
+    const result = await complete(request, { url: url.href });
+    if ("error" in result)
+      return Response.json({ error: result.error }, { headers, status: 400 });
+    headers.append(
+      "set-cookie",
+      serialize({
+        name: names.session,
+        value: result.id
+      })
+    );
+    return Response.json({ session: pageSession(result.session) }, { headers });
+  }
+  async function complete(request, options2) {
+    const id = get(request, { name: names.pending });
+    if (!id) return { error: "invalid_request" };
+    const session2 = await (async () => {
+      try {
+        return await backend.complete({ id, url: options2.url });
+      } catch (error) {
+        if (error instanceof PendingNotFoundError) return "invalid_request";
+        if (error instanceof RequestError) return error.code;
+        throw error;
+      }
+    })();
+    if (typeof session2 === "string") return { error: session2 };
+    const previous = get(request, {
+      name: names.session
+    });
+    if (previous && previous !== id)
+      await backend.end({ id: previous }).catch(() => void 0);
+    return { id, session: session2 };
+  }
+  async function logout(request) {
+    const refusal = foreign(request);
+    if (refusal) return refusal;
+    const id = get(request, { name: names.session });
+    const headers = new Headers({
+      "set-cookie": serialize({
+        name: names.session
+      })
+    });
+    const ended = id ? await backend.end({ id }).then(
+      () => true,
+      () => false
+    ) : true;
+    if (!ended)
+      return Response.json(
+        { error: "temporarily_unavailable" },
+        { headers, status: 503 }
+      );
+    return new Response(null, { headers, status: 204 });
+  }
+  async function session(request) {
+    const id = get(request, { name: names.session });
+    const current = id ? await backend.get({ id }) : void 0;
+    const headers = new Headers({ "cache-control": "no-store" });
+    if (id && !current)
+      headers.set(
+        "set-cookie",
+        serialize({ name: names.session })
+      );
+    return Response.json(
+      { session: current ? pageSession(current) : null },
+      { headers }
+    );
+  }
+  const routes = {
+    [`${base}/callback`]: { GET: callback, POST: dialogCallback },
+    [`${base}/login`]: { GET: login, POST: dialogLogin },
+    [`${base}/logout`]: { POST: logout },
+    [`${base}/session`]: { GET: session }
+  };
+  return from({
+    async fetch(request) {
+      const route = routes[new URL(request.url).pathname];
+      if (!route) return Response.json({ error: "not_found" }, { status: 404 });
+      const fn = route[request.method];
+      if (!fn)
+        return Response.json(
+          { error: "method_not_allowed" },
+          { headers: { allow: Object.keys(route).join(", ") }, status: 405 }
+        );
+      return fn(request);
+    }
+  });
+}
+function cleared() {
+  const headers = new Headers({ "cache-control": "no-store" });
+  for (const name of [
+    names.dialog,
+    names.pending,
+    names.return
+  ])
+    headers.append("set-cookie", serialize({ name }));
+  return headers;
+}
+function decode(value) {
+  if (value === void 0) return void 0;
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return void 0;
+  }
+}
+function foreign(request) {
+  if (request.headers.get("origin") === new URL(request.url).origin)
+    return void 0;
+  return Response.json(
+    {
+      error: "forbidden",
+      error_description: "Invalid origin: only a request from the app\u2019s own origin can call this route. Send the request from the app\u2019s page."
+    },
+    { status: 403 }
+  );
+}
+function pageSession(session) {
+  return { account: session.key?.account ?? null, user: session.user };
+}
+function relay() {
+  const nonce = crypto.randomUUID();
+  return new Response(
+    `<!doctype html><meta charset="utf-8"><title>Sign-in</title><p>Return to the app\u2019s window to continue.</p><script nonce="${nonce}">${relayScript}</script>`,
+    {
+      headers: {
+        "cache-control": "no-store",
+        "content-security-policy": `default-src 'none'; script-src 'nonce-${nonce}'`,
+        "content-type": "text/html; charset=utf-8",
+        "referrer-policy": "no-referrer"
+      }
+    }
+  );
+}
+function returnTo(value, options) {
+  if (!value?.startsWith("/")) return "/";
+  const url = (() => {
+    try {
+      return new URL(value, options.origin);
+    } catch {
+      return void 0;
+    }
+  })();
+  if (url?.origin !== options.origin) return "/";
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+function withError(path, options) {
+  const url = new URL(path, options.origin);
+  url.searchParams.set("error", options.error);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+// ../../accounts/src/internal/handlers/Server.ts
+function create2(options) {
+  const { accessKeys, relay: relay2 } = options;
+  const base = (options.basePath ?? basePath).replace(/\/+$/, "");
+  const backend = options.backend ? create({
+    backend: options.backend,
+    basePath: base,
+    redirectUri: options.redirectUri
+  }) : void 0;
+  const backendPaths = new Set(
+    ["/callback", "/login", "/logout", "/session"].map(
+      (path) => `${base}${path}`
+    )
+  );
+  return from({
+    async fetch(request) {
+      const { pathname } = new URL(request.url);
+      if (accessKeys && pathname === `${base}/access-keys`)
+        return (await accessKeys()).fetch(request);
+      if (backend && backendPaths.has(pathname)) return backend.fetch(request);
+      if (relay2 && pathname === `${base}/relay`) return relay2().fetch(request);
+      return Response.json({ error: "not_found" }, { status: 404 });
+    }
+  });
+}
+export {
+  create2 as create
+};

package/dist/{Sheet-PXWIG5RT.js → Sheet-D644QHD6.js}

@@ -4,7 +4,8 @@ import {
   machines,
   prompt,
   waiting
-} from "./chunk-AUGJ5ANC.js";
+} from "./chunk-OR4H7ZKK.js";
+import "./chunk-2BJJYAAI.js";
 import "./chunk-MLKGABMK.js";
 export {
   create,