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

package/dist/drop-core/authedDropClient.d.ts

@@ -0,0 +1,100 @@
+import { DropClient } from './client';
+import { Digest, DropResponse } from './types';
+export interface AuthenticatedDropClientConfig {
+    /**
+     * Base for JSON API calls, routed through the consumer's access-control
+     * rewrite so the session cookie authenticates them. On netlify.com that
+     * rewrite is `/access-control/*` → the app's access-control function, which
+     * makes `/access-control/bb-api/api/v1` the API root (the default here).
+     */
+    proxyBase?: string;
+    /**
+     * Direct API base for the file uploads. The proxy above runs in a Lambda with
+     * a ~6MB request body limit, so file PUTs go straight to `api.netlify.com`
+     * (whose `/api/*` CORS policy allows any origin).
+     */
+    apiBase?: string;
+    /**
+     * Mint a bearer token for those direct uploads. 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`.
+     *
+     * Called repeatedly, not once: the token issued to a non-app origin lives
+     * only 30 seconds, which a multi-file upload routinely outlasts.
+     */
+    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.
+ *
+ * Requests split across two hosts by necessity. JSON calls (create the site,
+ * create the deploy, poll it) go through the consumer's access-control proxy on
+ * the session cookie — no token involved, and nothing that can expire mid-deploy.
+ * File uploads can't: the proxy caps bodies at ~6MB, so they go direct to
+ * `api.netlify.com` with a bearer, re-minted as it ages (see `TOKEN_REUSE_MS`).
+ *
+ * Error-mapping invariant: only pre-mutation failures — a null upload token at
+ * the gate, or a 401/403 creating the site — throw `NotAuthenticatedError`,
+ * which is the signal the drop flow may safely retry anonymously. Once the site
+ * exists, any auth failure throws a plain 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 proxyBase;
+    private apiBase;
+    private getUploadToken;
+    private accountSlug?;
+    private pollIntervalMs;
+    private timeoutMs;
+    private cachedToken?;
+    constructor({ proxyBase, apiBase, getUploadToken, accountSlug, pollIntervalMs, timeoutMs, }: AuthenticatedDropClientConfig);
+    /**
+     * The auth gate. Minting here — before anything is created — is what lets a
+     * logged-out visitor fail cleanly and fall back to the anonymous flow. The
+     * returned token is threaded through `deployFiles`, but only the uploads
+     * actually need one, and they re-mint rather than trusting this to still be
+     * valid by the time they run.
+     */
+    getToken(): Promise<string>;
+    /**
+     * A token young enough to authorize an upload, minting a new one once the
+     * cached one nears its 30s expiry.
+     *
+     * Deliberately NOT `NotAuthenticatedError` when minting fails: by the time
+     * uploads run the site already exists, and that error would send the drop
+     * back through the anonymous path — leaving an empty project behind and
+     * deploying a duplicate. See the class doc.
+     */
+    private freshToken;
+    /**
+     * Two proxied 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>;
+    /**
+     * Direct to `api.netlify.com` on a freshly-aged bearer — the threaded `token`
+     * is ignored because an upload queue easily outlives the 30 seconds it was
+     * minted with. PUT (not POST) so paths with "&" etc. work.
+     */
+    uploadFile(deployId: string, path: string, content: ArrayBuffer, _token: string): Promise<void>;
+    /**
+     * Poll the deploy through the proxy until it settles: resolve on `ready`,
+     * throw on `error`/`rejected`, throw on timeout. On the session cookie rather
+     * than a bearer, so a deploy taking minutes can't outlive its own credentials.
+     */
+    waitUntilReady(deploy: DropResponse, _token: string): Promise<void>;
+}

package/dist/drop-core/authedDropClient.js

@@ -0,0 +1,109 @@
+var l = Object.defineProperty;
+var c = (i, e, t) => e in i ? l(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var a = (i, e, t) => c(i, typeof e != "symbol" ? e + "" : e, t);
+import { DEFAULT_PROXY_BASE as p, DEFAULT_API_BASE as h, DEFAULT_POLL_INTERVAL_MS as u, DEFAULT_TIMEOUT_MS as y, createSiteInAccount as T, pollDeployUntilSettled as w } from "./authedApi.js";
+import { apiError as d } from "./client.js";
+import { NotAuthenticatedError as m } from "./errors.js";
+const k = 20 * 1e3;
+class M {
+  constructor({
+    proxyBase: e = p,
+    apiBase: t = h,
+    getUploadToken: o,
+    accountSlug: s,
+    pollIntervalMs: n = u,
+    timeoutMs: r = y
+  }) {
+    a(this, "proxyBase");
+    a(this, "apiBase");
+    a(this, "getUploadToken");
+    a(this, "accountSlug");
+    a(this, "pollIntervalMs");
+    a(this, "timeoutMs");
+    a(this, "cachedToken");
+    this.proxyBase = e, this.apiBase = t, this.getUploadToken = o, this.accountSlug = s, this.pollIntervalMs = n, this.timeoutMs = r;
+  }
+  /**
+   * The auth gate. Minting here — before anything is created — is what lets a
+   * logged-out visitor fail cleanly and fall back to the anonymous flow. The
+   * returned token is threaded through `deployFiles`, but only the uploads
+   * actually need one, and they re-mint rather than trusting this to still be
+   * valid by the time they run.
+   */
+  async getToken() {
+    const e = await this.getUploadToken();
+    if (!e) throw new m();
+    return this.cachedToken = { value: e, mintedAt: Date.now() }, e;
+  }
+  /**
+   * A token young enough to authorize an upload, minting a new one once the
+   * cached one nears its 30s expiry.
+   *
+   * Deliberately NOT `NotAuthenticatedError` when minting fails: by the time
+   * uploads run the site already exists, and that error would send the drop
+   * back through the anonymous path — leaving an empty project behind and
+   * deploying a duplicate. See the class doc.
+   */
+  async freshToken() {
+    const e = Date.now();
+    if (this.cachedToken && e - this.cachedToken.mintedAt < k)
+      return this.cachedToken.value;
+    const t = await this.getUploadToken();
+    if (!t) throw new Error("could not renew the upload token");
+    return this.cachedToken = { value: t, mintedAt: e }, t;
+  }
+  /**
+   * Two proxied 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(e, t) {
+    const o = await T(this.proxyBase, this.accountSlug), s = await fetch(`${this.proxyBase}/sites/${o.id}/deploys`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ files: e, deploy_source: "drop" })
+    });
+    if (!s.ok) throw d("deploy create", s.status);
+    const n = await s.json();
+    return {
+      id: o.id,
+      deploy_id: n.id,
+      subdomain: o.name,
+      required: n.required ?? []
+    };
+  }
+  /**
+   * Direct to `api.netlify.com` on a freshly-aged bearer — the threaded `token`
+   * is ignored because an upload queue easily outlives the 30 seconds it was
+   * minted with. PUT (not POST) so paths with "&" etc. work.
+   */
+  async uploadFile(e, t, o, s) {
+    const n = await this.freshToken(), r = await fetch(`${this.apiBase}/deploys/${e}/files${t}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${n}` },
+      body: o
+    });
+    if (!r.ok) throw d(`upload ${t}`, r.status);
+  }
+  /**
+   * Poll the deploy through the proxy until it settles: resolve on `ready`,
+   * throw on `error`/`rejected`, throw on timeout. On the session cookie rather
+   * than a bearer, so a deploy taking minutes can't outlive its own credentials.
+   */
+  async waitUntilReady(e, t) {
+    const o = await w({
+      proxyBase: this.proxyBase,
+      deployId: e.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (o.outcome !== "ready")
+      throw o.outcome === "failed" ? new Error(
+        o.errorMessage ? `deploy failed: ${o.errorMessage}` : "deploy failed"
+      ) : new Error("Deploy did not become ready in time");
+  }
+}
+export {
+  M as AuthenticatedDropClient
+};

package/dist/drop-core/authedDropClient.test.d.ts

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

package/dist/{components/preact/DropZone/drop-core → drop-core}/buildClient.d.ts

@@ -1,13 +1,5 @@
-/** The subset of a Netlify Site the drop flow needs to redirect and report. */
-export interface BuildSite {
-    /** site id (UUID) */
-    id: string;
-    /** the *.netlify.app subdomain, also the app's URL segment */
-    name: string;
-    /** https://<name>.netlify.app */
-    ssl_url?: string;
-    url?: string;
-}
+import { BuildSite } from './types';
+export type { BuildSite } from './types';
 /** The subset of a Netlify Build returned by `POST /sites/{id}/builds`. */
 export interface BuildResponse {
     /** build id */
@@ -22,20 +14,27 @@ export interface BuildClient {
 }
 export interface AuthenticatedBuildClientConfig {
     /**
-     * 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
-     * creation and deploy reads are not on the list for netlify.com (they 400
-     * with `x-debug: request origin not allowed to call endpoint`). The zip
-     * upload could not use that proxy regardless: it runs in a Lambda with a
-     * ~6MB request body limit.
+     * Base for JSON API calls, routed through the consumer's access-control
+     * rewrite so the session cookie authenticates them. On netlify.com that
+     * rewrite is `/access-control/*` → the app's access-control function, which
+     * makes `/access-control/bb-api/api/v1` the API root (the default here).
+     */
+    proxyBase?: string;
+    /**
+     * Direct API base for the zip upload. The proxy above runs in a Lambda with a
+     * ~6MB request body limit, so the multipart POST has to go straight to
+     * `api.netlify.com` (whose `/api/*` CORS policy allows any origin).
      */
     apiBase?: string;
     /**
-     * Mint a short-lived bearer token authorizing the calls. On netlify.com this
-     * is `GET /access-control/generate-access-control-token`, whose
+     * Mint a bearer token for that direct upload. 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`.
+     *
+     * Note the token issued to a non-app origin lives only 30 seconds. It is
+     * minted immediately before the upload, but a zip that takes longer than that
+     * to transfer will still be rejected mid-flight — see `createBuildFromZip`.
      */
     getUploadToken: () => Promise<string | null>;
     /** Create the site in this account. Omit to use the user's default account. */
@@ -60,16 +59,18 @@ export interface AuthenticatedBuildClientConfig {
  * short-lived bearer token because the proxy can't carry a body that large.
  */
 export declare class AuthenticatedBuildClient implements BuildClient {
+    private proxyBase;
     private apiBase;
     private getUploadToken;
     private accountSlug?;
     private title;
     private pollIntervalMs;
     private timeoutMs;
-    constructor({ apiBase, getUploadToken, accountSlug, title, pollIntervalMs, timeoutMs, }: AuthenticatedBuildClientConfig);
+    constructor({ proxyBase, apiBase, getUploadToken, accountSlug, title, pollIntervalMs, timeoutMs, }: AuthenticatedBuildClientConfig);
     /**
-     * Create the site the build deploys into. Authorized by the bearer token;
-     * without an account slug the API picks the user's default account.
+     * Create the site the build deploys into. A logged-out visitor fails here,
+     * before anything is created — see `createSiteInAccount` for the error
+     * mapping that makes the signup fallback safe.
      */
     createSite(): Promise<BuildSite>;
     /**
@@ -77,6 +78,11 @@ export declare class AuthenticatedBuildClient implements BuildClient {
      * (see the note on `apiBase`), authorized by a freshly minted bearer token.
      * `Content-Type` is left unset on purpose so the browser adds the multipart
      * boundary itself.
+     *
+     * Known ceiling: this is one request on a 30s token, and re-minting can't
+     * help once it is in flight. A zip that takes longer than that to upload will
+     * fail — the app origin gets 300s for exactly this reason, and lifting the
+     * limit for other origins is a platform-side change.
      */
     createBuildFromZip(siteId: string, zip: File): Promise<BuildResponse>;
     /**
@@ -86,10 +92,10 @@ export declare class AuthenticatedBuildClient implements BuildClient {
      * deploy id yet has nothing pollable, so it resolves immediately and the
      * caller falls back to the site page.
      *
-     * Optional in the drop flow, and off by default: a build takes minutes, which
-     * can outlive the bearer token minted for it. Each poll re-mints so a long
-     * build keeps reading; a token that can't be minted any more ends the wait as
-     * a timeout rather than a false failure.
+     * Optional in the drop flow, and off by default: a build takes minutes, so
+     * the useful hand-off is usually the project page rather than a spinner.
+     * Polling rides the session cookie, so it cannot outlive its credentials the
+     * way a 30s bearer would.
      */
     waitUntilBuildReady(build: BuildResponse): Promise<void>;
 }

package/dist/drop-core/buildClient.js

@@ -0,0 +1,84 @@
+var d = Object.defineProperty;
+var p = (r, t, e) => t in r ? d(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
+var o = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+import { DEFAULT_PROXY_BASE as c, DEFAULT_API_BASE as h, DEFAULT_POLL_INTERVAL_MS as B, DEFAULT_TIMEOUT_MS as m, createSiteInAccount as y, pollDeployUntilSettled as w } from "./authedApi.js";
+import { NotAuthenticatedError as l, BuildCreateError as A, BuildFailedError as E, BuildTimeoutError as M } from "./errors.js";
+class _ {
+  constructor({
+    proxyBase: t = c,
+    apiBase: e = h,
+    getUploadToken: a,
+    accountSlug: s,
+    title: i = "Build from drop deployment",
+    pollIntervalMs: n = B,
+    timeoutMs: u = m
+  }) {
+    o(this, "proxyBase");
+    o(this, "apiBase");
+    o(this, "getUploadToken");
+    o(this, "accountSlug");
+    o(this, "title");
+    o(this, "pollIntervalMs");
+    o(this, "timeoutMs");
+    this.proxyBase = t, this.apiBase = e, this.getUploadToken = a, this.accountSlug = s, this.title = i, this.pollIntervalMs = n, this.timeoutMs = u;
+  }
+  /**
+   * Create the site the build deploys into. A logged-out visitor fails here,
+   * before anything is created — see `createSiteInAccount` for the error
+   * mapping that makes the signup fallback safe.
+   */
+  async createSite() {
+    return y(this.proxyBase, this.accountSlug);
+  }
+  /**
+   * Upload the source archive and enqueue a build. Direct to `api.netlify.com`
+   * (see the note on `apiBase`), authorized by a freshly minted bearer token.
+   * `Content-Type` is left unset on purpose so the browser adds the multipart
+   * boundary itself.
+   *
+   * Known ceiling: this is one request on a 30s token, and re-minting can't
+   * help once it is in flight. A zip that takes longer than that to upload will
+   * fail — the app origin gets 300s for exactly this reason, and lifting the
+   * limit for other origins is a platform-side change.
+   */
+  async createBuildFromZip(t, e) {
+    const a = await this.getUploadToken();
+    if (!a) throw new l();
+    const s = new FormData();
+    s.append("zip", e), s.append("title", this.title);
+    const i = await fetch(`${this.apiBase}/sites/${t}/builds`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${a}` },
+      body: s
+    });
+    if (i.status === 401 || i.status === 403) throw new l();
+    if (!i.ok) throw new A(i.status);
+    return i.json();
+  }
+  /**
+   * Poll the build's deploy until it settles, mirroring
+   * `AnonymousDropClient.waitUntilReady` — resolve on `ready`, throw on
+   * `error`/`rejected`, throw on timeout. A build that hasn't been given a
+   * deploy id yet has nothing pollable, so it resolves immediately and the
+   * caller falls back to the site page.
+   *
+   * Optional in the drop flow, and off by default: a build takes minutes, so
+   * the useful hand-off is usually the project page rather than a spinner.
+   * Polling rides the session cookie, so it cannot outlive its credentials the
+   * way a 30s bearer would.
+   */
+  async waitUntilBuildReady(t) {
+    if (!t.deploy_id) return;
+    const e = await w({
+      proxyBase: this.proxyBase,
+      deployId: t.deploy_id,
+      pollIntervalMs: this.pollIntervalMs,
+      timeoutMs: this.timeoutMs
+    });
+    if (e.outcome !== "ready")
+      throw e.outcome === "failed" ? new E(e.errorMessage) : new M();
+  }
+}
+export {
+  _ as AuthenticatedBuildClient
+};

package/dist/drop-core/buildClient.test.d.ts

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

package/dist/drop-core/buildStash.d.ts

@@ -0,0 +1,37 @@
+import { InferredBuildSettings } from './detectBuild';
+/**
+ * Carry a build-required drop across the signup round-trip.
+ *
+ * A logged-out visitor's drop can't be built (builds have no anonymous
+ * equivalent), so before handing them to signup the zone stashes the source
+ * archive here — IndexedDB, because the zip is far beyond localStorage's
+ * budget. When they return to this origin authenticated, the zone deploys the
+ * stash automatically instead of asking them to drop again.
+ *
+ * Storage is per-origin: a stash written on www.netlify.com can only ever be
+ * resumed on www.netlify.com. That is the design, not a limitation — it is
+ * exactly why the hand-off page must bring the visitor back here.
+ *
+ * Every operation is failure-swallowing: the stash is an enhancement, and a
+ * browser without IndexedDB (or with a full quota) degrades to the plain
+ * signup redirect the zone always supported.
+ */
+export interface DropBuildStash {
+    /** The `source.zip` exactly as it would have been uploaded. */
+    zipFile: File;
+    /** Settings synthesised into the archive's netlify.toml, if any. */
+    buildSettings: InferredBuildSettings | null;
+    createdAt: number;
+}
+/**
+ * Stash a drop's source archive for an automatic deploy after signup. Returns
+ * whether it was actually stored — callers use that only to phrase the
+ * hand-off, never to block it.
+ */
+export declare function saveDropStash(zipFile: File, buildSettings?: InferredBuildSettings | null): Promise<boolean>;
+/** The stashed drop, or null when there is none, it expired, or storage is unavailable. */
+export declare function loadDropStash(): Promise<DropBuildStash | null>;
+/** Remove the stash and its marker. Idempotent; never throws. */
+export declare function clearDropStash(): Promise<void>;
+/** Cheap synchronous check so page loads don't open IndexedDB just to look for a stash. */
+export declare function hasDropStashMarker(): boolean;

package/dist/drop-core/buildStash.js

@@ -0,0 +1,84 @@
+const f = "netlify-drop";
+const s = "build-stash", c = "latest", i = "dropBuildStash";
+const S = (e) => Promise.race([
+  e,
+  new Promise((r, t) => {
+    setTimeout(() => t(new Error("IndexedDB operation timed out")), 3e3);
+  })
+]), d = () => new Promise((e, r) => {
+  const t = indexedDB.open(f, 1);
+  t.onupgradeneeded = () => {
+    t.result.createObjectStore(s);
+  }, t.onsuccess = () => e(t.result), t.onerror = () => r(t.error);
+}), u = (e, r) => S(
+  d().then(
+    (t) => new Promise((o, a) => {
+      const n = r(t.transaction(s, e).objectStore(s));
+      n.onsuccess = () => {
+        t.close(), o(n.result);
+      }, n.onerror = () => {
+        t.close(), a(n.error);
+      };
+    })
+  )
+), p = async (e) => {
+  const { quota: r, usage: t } = await navigator.storage.estimate();
+  return r !== void 0 && t !== void 0 && r - t > e * 2;
+}, T = () => {
+  localStorage.setItem(i, JSON.stringify({ expiresAt: Date.now() + 864e5 }));
+}, l = () => {
+  localStorage.removeItem(i);
+};
+async function A(e, r = null) {
+  var t;
+  try {
+    if (typeof indexedDB > "u" || !((t = navigator.storage) != null && t.estimate) || e.size > 209715200 || !await p(e.size))
+      return !1;
+    const o = { zipFile: e, buildSettings: r, createdAt: Date.now() };
+    return await u("readwrite", (a) => a.put(o, c)), T(), !0;
+  } catch {
+    return !1;
+  }
+}
+async function D() {
+  try {
+    if (typeof indexedDB > "u") return null;
+    const e = await u(
+      "readonly",
+      (t) => t.get(c)
+    ), r = e && _(e.zipFile);
+    return !e || !r ? null : Date.now() - e.createdAt > 864e5 ? (await y(), null) : { ...e, zipFile: r };
+  } catch {
+    return null;
+  }
+}
+function _(e) {
+  return e instanceof File && e.name ? e : e instanceof Blob || e && typeof e.arrayBuffer == "function" ? new File([e], "source.zip", { type: "application/zip" }) : null;
+}
+async function y() {
+  try {
+    l();
+  } catch {
+  }
+  try {
+    if (typeof indexedDB > "u") return;
+    await u("readwrite", (e) => e.delete(c));
+  } catch {
+  }
+}
+function O() {
+  try {
+    const e = localStorage.getItem(i);
+    if (!e) return !1;
+    const { expiresAt: r } = JSON.parse(e);
+    return typeof r != "number" || Date.now() > r ? (l(), !1) : !0;
+  } catch {
+    return !1;
+  }
+}
+export {
+  y as clearDropStash,
+  O as hasDropStashMarker,
+  D as loadDropStash,
+  A as saveDropStash
+};

package/dist/{components/preact/DropZone/drop-core → drop-core}/deploy.d.ts

@@ -2,6 +2,7 @@ import { BuildClient, BuildResponse, BuildSite } from './buildClient';
 import { DropClient } from './client';
 import { InferredBuildSettings } from './detectBuild';
 import { DeployProgress, DeployResult, ProcessedFile } from './types';
+import { ZipResult } from './zip';
 export interface DeployOptions {
     onProgress?: (e: DeployProgress) => void;
 }
@@ -35,3 +36,9 @@ export interface BuildDeployOptions extends DeployOptions {
  * doesn't leave an empty site behind in the user's account.
  */
 export declare function deployBuild(client: BuildClient, files: ProcessedFile[], opts?: BuildDeployOptions): Promise<BuildDeployResult>;
+/**
+ * Deploy an archive that was already zipped — the resume path for a drop
+ * stashed across the signup round-trip (see `buildStash`), where `source.zip`
+ * and its synthesised settings were produced before the visitor left.
+ */
+export declare function deployZippedBuild(client: BuildClient, { file: zip, buildSettings }: ZipResult, opts?: BuildDeployOptions): Promise<BuildDeployResult>;

package/dist/drop-core/deploy.js

@@ -0,0 +1,53 @@
+import { getDigest as w } from "./digest.js";
+import { zipFiles as y } from "./zip.js";
+const r = 5;
+async function f(i, n, p, a, t, e) {
+  const l = p.filter((h) => a.has(h.sha));
+  let u = 0, c = 0;
+  const d = async () => {
+    for (; u < l.length; ) {
+      const h = l[u++];
+      await i.uploadFile(n, h.path, h.content, t), e == null || e(++c);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(r, l.length) }, d));
+}
+async function B(i, n, p = {}) {
+  if (!n.length) throw new Error("No files to deploy");
+  const { onProgress: a } = p;
+  a == null || a({ phase: "creating" });
+  const t = await i.getToken(), e = await i.createDeploy(w(n), t), l = e.required.length;
+  return a == null || a({ phase: "uploading", uploaded: 0, total: l }), await f(
+    i,
+    e.deploy_id,
+    n,
+    new Set(e.required),
+    t,
+    (u) => a == null ? void 0 : a({ phase: "uploading", uploaded: u, total: l })
+  ), a == null || a({ phase: "processing" }), await i.waitUntilReady(e, t), a == null || a({ phase: "ready" }), { deploy: e, token: t, url: `https://${e.subdomain}.netlify.app` };
+}
+async function F(i, n, p = {}) {
+  var t;
+  if (!n.length) throw new Error("No files to deploy");
+  (t = p.onProgress) == null || t.call(p, { phase: "zipping" });
+  const a = await y(n);
+  return o(i, a, p);
+}
+async function o(i, { file: n, buildSettings: p }, a = {}) {
+  const { onProgress: t, waitForBuild: e = !1 } = a;
+  t == null || t({ phase: "creating" });
+  const l = await i.createSite();
+  t == null || t({ phase: "uploading" });
+  const u = await i.createBuildFromZip(l.id, n);
+  return t == null || t({ phase: "building" }), e && await i.waitUntilBuildReady(u), t == null || t({ phase: "ready" }), {
+    site: l,
+    build: u,
+    buildSettings: p,
+    url: l.ssl_url || l.url || `https://${l.name}.netlify.app`
+  };
+}
+export {
+  F as deployBuild,
+  B as deployFiles,
+  o as deployZippedBuild
+};

package/dist/drop-core/deploy.test.d.ts

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

package/dist/drop-core/detectBuild.test.d.ts

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

package/dist/drop-core/digest.test.d.ts

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

package/dist/{components/preact/DropZone/drop-core → drop-core}/errors.js

@@ -40,7 +40,7 @@ function h(e) {
   if (e instanceof o)
     return "To deploy, drop a folder or a .zip file — or a single HTML page.";
   if (e instanceof s)
-    return "Please log in to Netlify to deploy a project that needs a build, then try again.";
+    return "Please log in to Netlify to deploy this project, then try again.";
   if (e instanceof u)
     return "We couldn't create a project for this build. Please try again.";
   if (e instanceof l)

package/dist/drop-core/errors.test.d.ts

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

package/dist/drop-core/fileTypes.test.d.ts

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

package/dist/{components/preact/DropZone/drop-core → drop-core}/index.d.ts

@@ -4,8 +4,11 @@ export * from './readFiles';
 export * from './fileTypes';
 export * from './detectBuild';
 export * from './client';
+export * from './authedApi';
 export * from './authedDropClient';
 export * from './buildClient';
 export * from './zip';
+export * from './buildStash';
 export * from './deploy';
 export * from './errors';
+export * from './analytics';