@netlify/spark-ui 1.30.0 → 1.31.0-alpha.2

package/dist/components/articleCopyActions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Wire up the "Copy URL" / "Copy page" buttons rendered by ArticleCopyActions.astro.
+ *
+ * This runs on every `astro:page-load` (initial load *and* every client-side
+ * navigation via `<ClientRouter />`), so the buttons keep working after routing
+ * to another article/post. Each wrapper is guarded so re-initialising the same
+ * DOM node never attaches duplicate listeners.
+ */
+export declare function initArticleCopyActions(root?: ParentNode): void;

package/dist/components/articleCopyActions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/index.d.ts

@@ -5,6 +5,6 @@ export { default as SearchLink } from './preact/SearchModal/components/SearchLin
 export { default as SearchHeading } from './preact/SearchModal/components/SearchHeading/SearchHeading';
 export { default as SearchToggle } from './preact/SearchModal/components/SearchToggle/SearchToggle';
 export { default as SearchModal } from './preact/SearchModal/components/SearchModal/SearchModal';
-export { DropZone, AnonymousDropClient, deployFiles, readDataTransfer, readFileList, } from './preact/DropZone';
-export type { DropClient, DropResponse, Digest, DeployResult, DeployProgress, DeployPhase, ProcessedFile, } from './preact/DropZone';
+export { DropZone, AnonymousDropClient, AuthenticatedBuildClient, AuthenticatedDropClient, deployBuild, deployFiles, detectBuild, inferBuildSettings, readDataTransfer, readFileList, zipFiles, } from './preact/DropZone';
+export type { AuthenticatedBuildClientConfig, AuthenticatedDropClientConfig, BuildClient, BuildDeployResult, BuildDetection, BuildSite, DeployedBuild, DeployedSite, DropClient, DropResponse, Digest, DeployResult, DeployProgress, DeployPhase, InferredBuildSettings, ProcessedFile, } from './preact/DropZone';
 export { type IconName } from './preact/Icon';

package/dist/components/preact/DropZone/DropZone.d.ts

@@ -1,6 +1,6 @@
 import { ComponentChildren } from 'preact';
-import { BuildDetection, DropClient } from './drop-core';
-import { DeployedSite, DeployError, TrackFn } from './useDropDeploy';
+import { BuildClient, BuildDetection, DropClient } from './drop-core';
+import { DeployedBuild, DeployedSite, DeployError, TrackFn } from './useDropDeploy';
 interface Props {
     /** Content the drop layer sits on top of. The zone is invisible until you drag over it. */
     children?: ComponentChildren;
@@ -10,23 +10,74 @@ interface Props {
     client?: DropClient;
     /** Build the "claim this site" URL from the assigned site name (subdomain). */
     claimUrl?: (siteName: string) => string;
+    /**
+     * Where an authenticated static deploy sends the visitor — the site already
+     * lives in their account, so there is no claim step. Defaults to the new
+     * site's project overview on app.netlify.com.
+     */
+    siteDashboardUrl?: (siteName: string) => string;
     /**
      * Where to send a build-required drop (framework source, build command,
-     * functions) when `onBuildRequired` isn't set. Such projects can't deploy
-     * through the anonymous static drop API, so by default the user is redirected
-     * here — the app signup page with `next=/drop` — to build on the
-     * authenticated Drop page. Override to point at your own destination.
+     * functions) that can't be built here — no `getUploadToken`/`buildClient`, or a
+     * visitor who isn't logged in. Such projects can't deploy through the anonymous
+     * static drop API, so by default the user is redirected here — the app signup
+     * page with `next=/drop` — to build on the authenticated Drop page. Override to
+     * point at your own destination.
      */
     buildSignupUrl?: string;
     /**
-     * Called when a build-required drop is detected, instead of the default
-     * `buildSignupUrl` redirect. Use it to own the hand-off yourself (custom
-     * routing, persisting the drop, gating on auth). When set, the component does
-     * not redirect. The static drop path is unaffected either way.
+     * Mint a short-lived bearer token for direct api.netlify.com uploads — pass it
+     * to switch on the whole authenticated path for logged-in visitors: static
+     * drops deploy straight into their account (then `siteDashboardUrl`), and
+     * build-required drops build in place instead of being handed off to the app.
+     * On netlify.com this reads `GET /access-control/generate-access-control-token`.
+     * Resolving `null` means "no session": static drops fall back to the anonymous
+     * claim flow, build drops to `buildSignupUrl`.
+     * See [Logged-in visitors](#logged-in-visitors).
+     */
+    getUploadToken?: () => Promise<string | null>;
+    /**
+     * Inject a custom `BuildClient` (tests, staging, a different account flow).
+     * Takes precedence over `getUploadToken` for the build path.
+     */
+    buildClient?: BuildClient;
+    /**
+     * Inject a custom authenticated `DropClient` for static drops (tests, staging,
+     * a different account flow). Takes precedence over `getUploadToken` for the
+     * static path. Distinct from `client`, which is the anonymous fallback.
+     */
+    authenticatedDropClient?: DropClient;
+    /** Create the visitor's new project in this account. Omit for their default account. */
+    accountSlug?: string;
+    /**
+     * Where an enqueued build sends the visitor. Defaults to the new site's
+     * project overview, same as a static deploy; `build.deployId` is available for
+     * consumers who want the deploy-log page instead.
+     */
+    buildDeployUrl?: (build: DeployedBuild) => string;
+    /**
+     * Poll until the build finishes before handing off, instead of redirecting as
+     * soon as it's enqueued. The trade-off: waiting means a failing build surfaces
+     * its own error message here (via `onError` and the overlay) rather than the
+     * visitor discovering it on the deploy page — at the cost of holding them on a
+     * spinner for the length of the build, which is minutes. Off by default.
+     */
+    waitForBuild?: boolean;
+    /**
+     * Called when a build-required drop is detected, instead of building it or
+     * redirecting. Use it to own the hand-off yourself (custom routing, persisting
+     * the drop, gating on auth). When set, the component neither builds nor
+     * redirects. The static drop path is unaffected either way.
      */
     onBuildRequired?: (info: BuildDetection) => void;
     /** Called once the deploy is live. */
     onDeploy?: (result: DeployedSite) => void;
+    /**
+     * Called once a build-required drop has been zipped, uploaded and enqueued —
+     * before the redirect to `buildDeployUrl`. The site exists at this point but
+     * won't serve content until the build finishes.
+     */
+    onBuildDeploy?: (build: DeployedBuild) => void;
     /**
      * Called when a deploy fails, with a humanized `message` (ready to show a
      * user — the same copy the built-in overlay uses) and the raw `reason`. Pair
@@ -48,10 +99,14 @@ interface Props {
      * Emitted events (all include `dropzone_id` when `analyticsId` is set):
      * - `dropzone_files_dropped`  — files dropped via drag  ({ method: 'drag', file_count, file_types })
      * - `dropzone_browse_opened`  — file picker opened       ({ method: 'keyboard' | 'click' })
-     * - `dropzone_build_required` — drop needs a build; handed off to signup ({ method, reason, file_count, file_types })
-     * - `dropzone_deploy_succeeded` — deploy went live       ({ method, site_name, file_count, file_types })
-     * - `dropzone_deploy_failed`  — deploy errored out       ({ method, reason, file_count?, file_types })
+     * - `dropzone_build_required` — drop needs a build (built here, or handed off) ({ method, reason, file_count, file_types })
+     * - `dropzone_deploy_succeeded` — static deploy went live ({ method, site_name, file_count, authenticated, auth_fallback?, file_types })
+     * - `dropzone_build_deploy_succeeded` — build enqueued for a logged-in visitor ({ method, reason, site_name, file_count, framework?, file_types })
+     * - `dropzone_deploy_failed`  — deploy or build errored out ({ method, reason, file_count?, file_types })
      *
+     * `authenticated` says whether the deploy landed in the visitor's account;
+     * `auth_fallback: true` is sent only when an authenticated attempt bounced
+     * (stale auth hint) and the drop completed anonymously — omitted otherwise.
      * `file_types` is the sorted, de-duplicated list of MIME types in the
      * selection, with `application/octet-stream` standing in wherever the browser
      * reports none (a dragged folder, an `.exe`). It is omitted when the browser
@@ -68,5 +123,5 @@ interface Props {
     analyticsId?: string;
     className?: string;
 }
-export default function DropZone({ children, apiBase, client, claimUrl, buildSignupUrl, onBuildRequired, onDeploy, onError, showStatus, onTrack, analyticsId, className, }: Props): import("preact").JSX.Element;
+export default function DropZone({ children, apiBase, client, claimUrl, siteDashboardUrl, buildSignupUrl, getUploadToken, buildClient, authenticatedDropClient, accountSlug, buildDeployUrl, waitForBuild, onBuildRequired, onDeploy, onBuildDeploy, onError, showStatus, onTrack, analyticsId, className, }: Props): import("preact").JSX.Element;
 export {};

package/dist/components/preact/DropZone/DropZone.js

@@ -1,159 +1,184 @@
 import { u as e } from "../../../chunks/jsxRuntime.module.Bzuv3cXw.js";
-import { A, d as I, y as P } from "../../../chunks/hooks.module.DRcxknIz.js";
-import { readFileList as U, readDataTransfer as j } from "./drop-core/readFiles.js";
+import { A as j, d as V, y as G } from "../../../chunks/hooks.module.DRcxknIz.js";
+import { readFileList as K, readDataTransfer as L } from "./drop-core/readFiles.js";
 import { getFileTypes as D } from "./drop-core/fileTypes.js";
 import "./drop-core/detectBuild.js";
-import { useDropDeploy as B } from "./useDropDeploy.js";
+import "./drop-core/zip.js";
+import { useDropDeploy as Z } from "./useDropDeploy.js";
 import { Fragment as w } from "preact";
-import '../../../assets/DropZone.css';const M = 120, N = (n) => `https://app.netlify.com/drop/${n}`, O = "https://app.netlify.com/signup?next=/drop&utm_campaign=drop";
-function W({
-  children: n,
-  apiBase: l,
-  client: i,
-  claimUrl: s = N,
-  buildSignupUrl: u = O,
-  onBuildRequired: T,
-  onDeploy: C,
-  onError: _,
+import '../../../assets/DropZone.css';const q = 120, H = (r) => `https://app.netlify.com/drop/${r}`, J = (r) => `https://app.netlify.com/projects/${r}`, Q = "https://app.netlify.com/signup?next=/drop&utm_campaign=drop", W = ({ siteName: r }) => `https://app.netlify.com/projects/${r}`;
+function se({
+  children: r,
+  apiBase: a,
+  client: l,
+  claimUrl: c = H,
+  siteDashboardUrl: u = J,
+  buildSignupUrl: A = Q,
+  getUploadToken: T,
+  buildClient: C,
+  authenticatedDropClient: S,
+  accountSlug: _,
+  buildDeployUrl: $ = W,
+  waitForBuild: B,
+  onBuildRequired: U,
+  onDeploy: P,
+  onBuildDeploy: R,
+  onError: x,
   showStatus: f = !0,
   onTrack: d,
   analyticsId: g,
-  className: S
+  className: E
 }) {
-  const m = (r, t = {}) => d == null ? void 0 : d(r, g ? { dropzone_id: g, ...t } : t), { status: a, warning: h, busy: o, deploy: v, reset: R } = B({
-    apiBase: l,
-    client: i,
-    claimUrl: s,
-    buildSignupUrl: u,
-    onBuildRequired: T,
-    onDeploy: C,
-    onError: _,
-    track: m
-  }), { active: p, keepActive: $, endDrag: x } = V(), y = A(null), b = (r) => {
-    var t;
-    m("dropzone_browse_opened", { method: r }), (t = y.current) == null || t.click();
-  }, E = f && (p || o || a.kind === "error"), F = [
+  const y = (t, n = {}) => d == null ? void 0 : d(t, g ? { dropzone_id: g, ...n } : n), { status: s, warning: b, busy: i, deploy: m, reset: F } = Z({
+    apiBase: a,
+    client: l,
+    claimUrl: c,
+    siteDashboardUrl: u,
+    buildSignupUrl: A,
+    getUploadToken: T,
+    buildClient: C,
+    authenticatedDropClient: S,
+    accountSlug: _,
+    buildDeployUrl: $,
+    waitForBuild: B,
+    onBuildRequired: U,
+    onDeploy: P,
+    onBuildDeploy: R,
+    onError: x,
+    track: y
+  }), { active: p, keepActive: I, endDrag: M } = X(), h = j(null), v = (t) => {
+    var n;
+    y("dropzone_browse_opened", { method: t }), (n = h.current) == null || n.click();
+  }, N = f && (p || i || s.kind === "error"), O = [
     "n-dropzone",
     p && "is-active",
-    o && "is-busy",
+    i && "is-busy",
     !f && "is-bare",
-    S
+    E
   ].filter(Boolean).join(" ");
   return /* @__PURE__ */ e(
     "div",
     {
-      class: F,
-      "data-state": a.kind,
+      class: O,
+      "data-state": s.kind,
       role: "button",
-      tabIndex: o ? -1 : 0,
+      tabIndex: i ? -1 : 0,
       "aria-label": "Drop a site folder or zip here to deploy it, or press Enter to browse for files",
-      "aria-busy": o,
-      onDragOver: (r) => {
-        o || (r.preventDefault(), $());
+      "aria-busy": i,
+      onDragOver: (t) => {
+        i || (t.preventDefault(), I());
       },
-      onDrop: (r) => {
-        if (r.preventDefault(), x(), o) return;
-        const t = r.dataTransfer;
-        t && v(() => j(t), "drag", D(t.files));
+      onDrop: (t) => {
+        if (t.preventDefault(), M(), i) return;
+        const n = t.dataTransfer;
+        n && m(() => L(n), "drag", D(n.files));
       },
-      onClick: (r) => {
-        !o && r.target === r.currentTarget && b("click");
+      onClick: (t) => {
+        !i && t.target === t.currentTarget && v("click");
       },
-      onKeyDown: (r) => {
-        o || (r.key === "Enter" || r.key === " ") && (r.preventDefault(), b("keyboard"));
+      onKeyDown: (t) => {
+        i || (t.key === "Enter" || t.key === " ") && (t.preventDefault(), v("keyboard"));
       },
       children: [
-        /* @__PURE__ */ e("div", { class: "n-dropzone-content", children: n }),
+        /* @__PURE__ */ e("div", { class: "n-dropzone-content", children: r }),
         /* @__PURE__ */ e(
           "input",
           {
-            ref: y,
+            ref: h,
             type: "file",
             hidden: !0,
             multiple: !0,
             webkitdirectory: "",
             directory: "",
-            onChange: (r) => {
-              var z;
-              const t = r.currentTarget;
-              if ((z = t.files) != null && z.length) {
-                const k = t.files;
-                v(() => U(k), "browse", D(k));
+            onChange: (t) => {
+              var k;
+              const n = t.currentTarget;
+              if ((k = n.files) != null && k.length) {
+                const z = n.files;
+                m(() => K(z), "browse", D(z));
               }
-              t.value = "";
+              n.value = "";
             }
           }
         ),
-        E && /* @__PURE__ */ e(
+        N && /* @__PURE__ */ e(
           "div",
           {
             class: "n-dropzone-overlay n-fadeIn",
             children: [
-              /* @__PURE__ */ e(G, { status: a, active: p, onReset: R }),
-              h && a.kind !== "error" && o && /* @__PURE__ */ e("p", { class: "n-dropzone-warning", role: "status", children: h })
+              /* @__PURE__ */ e(Y, { status: s, active: p, onReset: F }),
+              b && s.kind !== "error" && i && /* @__PURE__ */ e("p", { class: "n-dropzone-warning", role: "status", children: b })
             ]
           },
-          a.kind === "idle" ? "active" : a.kind
+          s.kind === "idle" ? "active" : s.kind
         )
       ]
     }
   );
 }
-function V() {
-  const [n, l] = I(!1), i = A();
-  return P(() => () => clearTimeout(i.current), []), { active: n, keepActive: () => {
-    l(!0), clearTimeout(i.current), i.current = setTimeout(() => l(!1), M);
+function X() {
+  const [r, a] = V(!1), l = j();
+  return G(() => () => clearTimeout(l.current), []), { active: r, keepActive: () => {
+    a(!0), clearTimeout(l.current), l.current = setTimeout(() => a(!1), q);
   }, endDrag: () => {
-    clearTimeout(i.current), l(!1);
+    clearTimeout(l.current), a(!1);
   } };
 }
-function G({
-  status: n,
-  active: l,
-  onReset: i
+function Y({
+  status: r,
+  active: a,
+  onReset: l
 }) {
-  switch (n.kind) {
+  switch (r.kind) {
     // Idle-but-active means a drag is hovering the zone.
     case "idle":
-      return l ? /* @__PURE__ */ e("p", { class: "n-dropzone-hint", children: "Drop to deploy" }) : null;
+      return a ? /* @__PURE__ */ e("p", { class: "n-dropzone-hint", children: "Drop to deploy" }) : null;
     case "reading":
-      return /* @__PURE__ */ e(c, { label: "Reading files…" });
+      return /* @__PURE__ */ e(o, { label: "Reading files…" });
+    case "zipping":
+      return /* @__PURE__ */ e(o, { label: "Packaging your project…" });
     case "creating":
-      return /* @__PURE__ */ e(c, { label: "Creating deploy…" });
+      return /* @__PURE__ */ e(o, { label: "Creating deploy…" });
     case "processing":
-      return /* @__PURE__ */ e(c, { label: "Processing — almost live…" });
+      return /* @__PURE__ */ e(o, { label: "Processing — almost live…" });
+    case "building":
+      return /* @__PURE__ */ e(o, { label: "Building your project…" });
     case "redirecting":
-      return /* @__PURE__ */ e(
-        c,
-        {
-          label: n.target === "signup" ? "This project needs a build — taking you to Netlify…" : "Site’s live — taking you to claim it…"
-        }
-      );
+      switch (r.target) {
+        case "signup":
+          return /* @__PURE__ */ e(o, { label: "This project needs a build — taking you to Netlify…" });
+        case "build":
+          return /* @__PURE__ */ e(o, { label: "Build started — taking you to your new project…" });
+        case "claim":
+          return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to claim it…" });
+        case "dashboard":
+          return /* @__PURE__ */ e(o, { label: "Site’s live — taking you to your new project…" });
+      }
     case "uploading": {
-      const s = n.total ? Math.round(n.uploaded / n.total * 100) : 0;
+      const c = r.total ? Math.round(r.uploaded / r.total * 100) : 0;
       return /* @__PURE__ */ e(w, { children: [
-        /* @__PURE__ */ e(c, { label: `Uploading ${n.uploaded}/${n.total} files…` }),
-        /* @__PURE__ */ e("div", { class: "n-dropzone-progress", role: "progressbar", "aria-valuenow": s, children: /* @__PURE__ */ e("div", { class: "n-dropzone-progress-bar", style: { width: `${s}%` } }) })
+        /* @__PURE__ */ e(o, { label: `Uploading ${r.uploaded}/${r.total} files…` }),
+        /* @__PURE__ */ e("div", { class: "n-dropzone-progress", role: "progressbar", "aria-valuenow": c, children: /* @__PURE__ */ e("div", { class: "n-dropzone-progress-bar", style: { width: `${c}%` } }) })
       ] });
     }
     case "error":
       return /* @__PURE__ */ e(w, { children: [
         /* @__PURE__ */ e("p", { class: "n-dropzone-title n-dropzone-title--error", children: "Something went wrong" }),
-        /* @__PURE__ */ e("p", { class: "n-dropzone-subtitle", role: "alert", children: n.message }),
-        /* @__PURE__ */ e("button", { type: "button", class: "n-dropzone-browse", onClick: i, children: "Try again" })
+        /* @__PURE__ */ e("p", { class: "n-dropzone-subtitle", role: "alert", children: r.message }),
+        /* @__PURE__ */ e("button", { type: "button", class: "n-dropzone-browse", onClick: l, children: "Try again" })
       ] });
   }
 }
-function c({ label: n }) {
+function o({ label: r }) {
   return /* @__PURE__ */ e("div", { class: "n-dropzone-loading", children: [
     /* @__PURE__ */ e("span", { class: "n-dropzone-spinner", "aria-hidden": "true" }),
     /* @__PURE__ */ e("p", { class: "n-dropzone-subtitle", "aria-live": "polite", children: [
-      n,
+      r,
       " ",
       /* @__PURE__ */ e("span", { class: "n-dropzone-nudge", children: "Please don’t refresh." })
     ] })
   ] });
 }
 export {
-  W as default
+  se as default
 };

package/dist/components/preact/DropZone/drop-core/authedDropClient.d.ts

@@ -0,0 +1,77 @@
+import { DropClient } from './client';
+import { Digest, DropResponse } from './types';
+export interface AuthenticatedDropClientConfig {
+    /**
+     * API base for every call. Requests go straight to `api.netlify.com`, whose
+     * `/api/*` CORS policy allows any origin, rather than through a consumer's
+     * access-control rewrite — that proxy allowlists paths per origin, and site
+     * and deploy creation are not on the list for netlify.com (they 400 with
+     * `x-debug: request origin not allowed to call endpoint`).
+     */
+    apiBase?: string;
+    /**
+     * Mint a short-lived bearer token authorizing the calls. On netlify.com this
+     * is `GET /access-control/generate-access-control-token`, whose
+     * `accessControlToken` the API decrypts back into the user's access token.
+     * Resolving `null` means "no session" and surfaces as `NotAuthenticatedError`.
+     */
+    getUploadToken: () => Promise<string | null>;
+    /** Create the site in this account. Omit to use the user's default account. */
+    accountSlug?: string;
+    /** How often to re-read the deploy while waiting. Default 1s. */
+    pollIntervalMs?: number;
+    /** How long to wait before giving up on the deploy. Default 10 minutes. */
+    timeoutMs?: number;
+}
+/**
+ * Authenticated drop client for logged-in visitors. Unlike `AnonymousDropClient`
+ * — which creates an account-less site the visitor must later claim — this
+ * deploys straight into the visitor's account via the sites/deploys API,
+ * mirroring what app.netlify.com does for a logged-in drag-and-drop deploy.
+ * There is no claim step, so the caller should hand off to the site's dashboard
+ * page rather than the claim page.
+ *
+ * Every request goes direct to `api.netlify.com` with the short-lived bearer
+ * from `getUploadToken()`. Routing the JSON calls through a consumer's
+ * access-control rewrite instead (cookie session, no token in the browser)
+ * would be the tighter design, but that proxy allowlists paths per origin and
+ * site/deploy creation isn't allowed from netlify.com — it 400s before
+ * reaching the API. Revisit if that allowlist gains these paths.
+ *
+ * Error-mapping invariant: only pre-mutation failures — a null upload token, or
+ * a 401/403 creating the site — throw `NotAuthenticatedError`, which is the
+ * signal the drop flow may safely retry anonymously. Once the site exists, an
+ * auth failure throws a plain status-carrying error instead: falling back at
+ * that point would strand an empty site in the account *and* deploy a duplicate
+ * anonymously.
+ */
+export declare class AuthenticatedDropClient implements DropClient {
+    private apiBase;
+    private getUploadToken;
+    private accountSlug?;
+    private pollIntervalMs;
+    private timeoutMs;
+    constructor({ apiBase, getUploadToken, accountSlug, pollIntervalMs, timeoutMs, }: AuthenticatedDropClientConfig);
+    /**
+     * The token here is the upload bearer, not a drop token — it authorizes every
+     * call this client makes. Minted once per deploy, before anything is created,
+     * so a missing session fails the whole attempt cleanly.
+     */
+    getToken(): Promise<string>;
+    /**
+     * Two calls: create the site in the visitor's account, then the deploy on it.
+     * Mapped into the anonymous `DropResponse` shape so `deployFiles` runs
+     * unchanged over either client.
+     */
+    createDeploy(files: Digest, token: string): Promise<DropResponse>;
+    uploadFile(deployId: string, path: string, content: ArrayBuffer, token: string): Promise<void>;
+    /**
+     * Poll until the deploy settles: resolve on `ready`, throw on
+     * `error`/`rejected`, throw on timeout. Reuses the bearer minted at the start
+     * of the deploy, so a deploy that outlives the token's TTL will start seeing
+     * 401s here — those are ignored like any other non-ok read and the loop runs
+     * to its timeout rather than failing fast. Acceptable while static deploys
+     * finish in seconds; re-mint per poll if that stops being true.
+     */
+    waitUntilReady(deploy: DropResponse, token: string): Promise<void>;
+}

package/dist/components/preact/DropZone/drop-core/authedDropClient.js

@@ -0,0 +1,97 @@
+var c = Object.defineProperty;
+var h = (r, t, e) => t in r ? c(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var n = (r, t, e) => h(r, typeof t != "symbol" ? t + "" : t, e);
+import { apiError as l } from "./client.js";
+import { NotAuthenticatedError as p, SiteCreateError as u } from "./errors.js";
+const y = "https://api.netlify.com/api/v1", w = 1e3, f = 10 * 60 * 1e3, m = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
+class g {
+  constructor({
+    apiBase: t = y,
+    getUploadToken: e,
+    accountSlug: i,
+    pollIntervalMs: o = w,
+    timeoutMs: s = f
+  }) {
+    n(this, "apiBase");
+    n(this, "getUploadToken");
+    n(this, "accountSlug");
+    n(this, "pollIntervalMs");
+    n(this, "timeoutMs");
+    this.apiBase = t, this.getUploadToken = e, this.accountSlug = i, this.pollIntervalMs = o, this.timeoutMs = s;
+  }
+  /**
+   * The token here is the upload bearer, not a drop token — it authorizes every
+   * call this client makes. Minted once per deploy, before anything is created,
+   * so a missing session fails the whole attempt cleanly.
+   */
+  async getToken() {
+    const t = await this.getUploadToken();
+    if (!t) throw new p();
+    return t;
+  }
+  /**
+   * Two calls: create the site in the visitor's account, then the deploy on it.
+   * Mapped into the anonymous `DropResponse` shape so `deployFiles` runs
+   * unchanged over either client.
+   */
+  async createDeploy(t, e) {
+    const i = this.accountSlug ? `/${this.accountSlug}/sites` : "/sites", o = await fetch(`${this.apiBase}${i}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${e}` },
+      body: JSON.stringify({ created_via: "drop" })
+    });
+    if (o.status === 401 || o.status === 403) throw new p();
+    if (!o.ok) throw new u(o.status);
+    const s = await o.json(), a = await fetch(`${this.apiBase}/sites/${s.id}/deploys`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${e}` },
+      body: JSON.stringify({ files: t, deploy_source: "drop" })
+    });
+    if (!a.ok) throw l("deploy create", a.status);
+    const d = await a.json();
+    return {
+      id: s.id,
+      deploy_id: d.id,
+      subdomain: s.name,
+      required: d.required ?? []
+    };
+  }
+  async uploadFile(t, e, i, o) {
+    const s = await fetch(`${this.apiBase}/deploys/${t}/files${e}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${o}` },
+      body: i
+    });
+    if (!s.ok) throw l(`upload ${e}`, s.status);
+  }
+  /**
+   * Poll until the deploy settles: resolve on `ready`, throw on
+   * `error`/`rejected`, throw on timeout. Reuses the bearer minted at the start
+   * of the deploy, so a deploy that outlives the token's TTL will start seeing
+   * 401s here — those are ignored like any other non-ok read and the loop runs
+   * to its timeout rather than failing fast. Acceptable while static deploys
+   * finish in seconds; re-mint per poll if that stops being true.
+   */
+  async waitUntilReady(t, e) {
+    const i = this.timeoutMs / this.pollIntervalMs;
+    for (let o = 0; o < i; o++) {
+      const s = await fetch(`${this.apiBase}/deploys/${t.deploy_id}`, {
+        headers: { Authorization: `Bearer ${e}` }
+      });
+      if (s.ok) {
+        const a = await s.json();
+        if (a.state && m.has(a.state)) {
+          if (a.state === "ready") return;
+          throw new Error(
+            a.error_message ? `deploy failed: ${a.error_message}` : "deploy failed"
+          );
+        }
+      }
+      await new Promise((a) => setTimeout(a, this.pollIntervalMs));
+    }
+    throw new Error("Deploy did not become ready in time");
+  }
+}
+export {
+  g as AuthenticatedDropClient
+};