@netlify/spark-ui 1.29.0 → 1.31.0-alpha.1

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

@@ -0,0 +1,98 @@
+/** 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;
+}
+/** The subset of a Netlify Build returned by `POST /sites/{id}/builds`. */
+export interface BuildResponse {
+    /** build id */
+    id: string;
+    /** the deploy the build produces — present as soon as the build is enqueued */
+    deploy_id?: string;
+}
+export interface BuildClient {
+    createSite(): Promise<BuildSite>;
+    createBuildFromZip(siteId: string, zip: File): Promise<BuildResponse>;
+    waitUntilBuildReady(build: BuildResponse): Promise<void>;
+}
+export interface AuthenticatedBuildClientConfig {
+    /**
+     * 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 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`.
+     */
+    getUploadToken: () => Promise<string | null>;
+    /** Create the site in this account. Omit to use the user's default account. */
+    accountSlug?: string;
+    /** Title recorded against the build. */
+    title?: string;
+    /** How often to re-read the deploy while waiting. Default 1s. */
+    pollIntervalMs?: number;
+    /** How long to wait before giving up on the build. Default 10 minutes. */
+    timeoutMs?: number;
+}
+/**
+ * Authenticated drop client for projects that need a build. Unlike
+ * `AnonymousDropClient` — which creates an account-less static site and can only
+ * upload pre-built files — this creates a real site in the user's account and
+ * hands buildbot a source archive to build, mirroring what app.netlify.com does
+ * for a drag-and-drop build.
+ *
+ * Requests split across two hosts by necessity: JSON calls go through the
+ * consumer's access-control proxy (cookie session, no token handling in the
+ * browser), while the zip upload goes direct to `api.netlify.com` with a
+ * 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({ proxyBase, apiBase, getUploadToken, accountSlug, title, pollIntervalMs, timeoutMs, }: AuthenticatedBuildClientConfig);
+    /**
+     * Create the site the build deploys into. Goes through the proxy with
+     * `credentials: 'include'` so the app session authorizes it; without an
+     * account slug the API picks the user's default account.
+     */
+    createSite(): Promise<BuildSite>;
+    /**
+     * 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.
+     */
+    createBuildFromZip(siteId: string, zip: File): Promise<BuildResponse>;
+    /**
+     * Poll the build's deploy through the proxy 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: a build takes minutes, so the default hand-off
+     * redirects to the app's deploy page (live logs) instead of waiting here.
+     */
+    waitUntilBuildReady(build: BuildResponse): Promise<void>;
+}

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

@@ -0,0 +1,92 @@
+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 i = (r, t, e) => p(r, typeof t != "symbol" ? t + "" : t, e);
+import { NotAuthenticatedError as n, SiteCreateError as h, BuildCreateError as u, BuildFailedError as w, BuildTimeoutError as y } from "./errors.js";
+const f = "/access-control/bb-api/api/v1", B = "https://api.netlify.com/api/v1", m = 1e3, S = 10 * 60 * 1e3, T = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
+class _ {
+  constructor({
+    proxyBase: t = f,
+    apiBase: e = B,
+    getUploadToken: a,
+    accountSlug: o,
+    title: s = "Build from drop deployment",
+    pollIntervalMs: l = m,
+    timeoutMs: c = S
+  }) {
+    i(this, "proxyBase");
+    i(this, "apiBase");
+    i(this, "getUploadToken");
+    i(this, "accountSlug");
+    i(this, "title");
+    i(this, "pollIntervalMs");
+    i(this, "timeoutMs");
+    this.proxyBase = t, this.apiBase = e, this.getUploadToken = a, this.accountSlug = o, this.title = s, this.pollIntervalMs = l, this.timeoutMs = c;
+  }
+  /**
+   * Create the site the build deploys into. Goes through the proxy with
+   * `credentials: 'include'` so the app session authorizes it; without an
+   * account slug the API picks the user's default account.
+   */
+  async createSite() {
+    const t = this.accountSlug ? `/${this.accountSlug}/sites` : "/sites", e = await fetch(`${this.proxyBase}${t}`, {
+      method: "POST",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ created_via: "drop" })
+    });
+    if (e.status === 401 || e.status === 403) throw new n();
+    if (!e.ok) throw new h(e.status);
+    return e.json();
+  }
+  /**
+   * 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.
+   */
+  async createBuildFromZip(t, e) {
+    const a = await this.getUploadToken();
+    if (!a) throw new n();
+    const o = new FormData();
+    o.append("zip", e), o.append("title", this.title);
+    const s = await fetch(`${this.apiBase}/sites/${t}/builds`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${a}` },
+      body: o
+    });
+    if (s.status === 401 || s.status === 403) throw new n();
+    if (!s.ok) throw new u(s.status);
+    return s.json();
+  }
+  /**
+   * Poll the build's deploy through the proxy 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: a build takes minutes, so the default hand-off
+   * redirects to the app's deploy page (live logs) instead of waiting here.
+   */
+  async waitUntilBuildReady(t) {
+    if (!t.deploy_id) return;
+    const e = this.timeoutMs / this.pollIntervalMs;
+    for (let a = 0; a < e; a++) {
+      const o = await fetch(`${this.proxyBase}/deploys/${t.deploy_id}`, {
+        credentials: "include"
+      });
+      if (o.ok) {
+        const s = await o.json();
+        if (s.state && T.has(s.state)) {
+          if (s.state === "ready") return;
+          throw new w(s.error_message);
+        }
+      }
+      await new Promise((s) => setTimeout(s, this.pollIntervalMs));
+    }
+    throw new y();
+  }
+}
+export {
+  _ as AuthenticatedBuildClient
+};

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

@@ -1,4 +1,8 @@
 import { DropResponse, Digest } from './types';
+/** A normal Error with the response's HTTP status attached, so callers can branch on it directly. */
+export declare function apiError(action: string, status: number): Error & {
+    status: number;
+};
 export interface DropClient {
     getToken(): Promise<string>;
     createDeploy(digest: Digest, token: string): Promise<DropResponse>;

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

@@ -40,5 +40,6 @@ class p {
   }
 }
 export {
-  p as AnonymousDropClient
+  p as AnonymousDropClient,
+  r as apiError
 };

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

@@ -1,6 +1,37 @@
+import { BuildClient, BuildResponse, BuildSite } from './buildClient';
 import { DropClient } from './client';
+import { InferredBuildSettings } from './detectBuild';
 import { DeployProgress, DeployResult, ProcessedFile } from './types';
 export interface DeployOptions {
     onProgress?: (e: DeployProgress) => void;
 }
 export declare function deployFiles(client: DropClient, files: ProcessedFile[], opts?: DeployOptions): Promise<DeployResult>;
+export interface BuildDeployResult {
+    /** The site created for this build. */
+    site: BuildSite;
+    /** The enqueued build; `deploy_id` is what the app's deploy page keys off. */
+    build: BuildResponse;
+    /** Settings synthesised into the uploaded `netlify.toml`, or null if none were. */
+    buildSettings: InferredBuildSettings | null;
+    /** The site's live URL — only serves content once the build finishes. */
+    url: string;
+}
+export interface BuildDeployOptions extends DeployOptions {
+    /**
+     * Poll until the build finishes instead of returning as soon as it's enqueued.
+     * Off by default: a build takes minutes, so the useful hand-off is usually the
+     * app's deploy page with its live logs, not a spinner. Turn it on when the
+     * caller needs to know the outcome — only then can a `BuildFailedError` reach
+     * it with the build's own error message.
+     */
+    waitForBuild?: boolean;
+}
+/**
+ * The build counterpart to `deployFiles`: zip the drop, create a site in the
+ * user's account, and hand the archive to buildbot. Requires an authenticated
+ * client — builds have no anonymous equivalent.
+ *
+ * Site creation deliberately happens *after* zipping, so a zip that fails
+ * doesn't leave an empty site behind in the user's account.
+ */
+export declare function deployBuild(client: BuildClient, files: ProcessedFile[], opts?: BuildDeployOptions): Promise<BuildDeployResult>;

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

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

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

@@ -21,3 +21,29 @@ export interface BuildDetection {
  * no build config) returns `{ buildRequired: false }`.
  */
 export declare function detectBuild(files: ProcessedFile[]): BuildDetection;
+/** Build settings confident enough to write into a `netlify.toml` for buildbot. */
+export interface InferredBuildSettings {
+    /** Build command, e.g. `"npm run build"`. */
+    command: string;
+    /** Publish directory relative to the deploy root, no leading slash, e.g. `"dist"`. */
+    publish: string;
+    /** The dependency the settings were inferred from, e.g. `"astro"`. */
+    framework: string;
+}
+/**
+ * Infer the build command and publish directory for a build-required drop, so
+ * `zipFiles` can write them into a `netlify.toml` that buildbot reads.
+ *
+ * Deliberately conservative: it returns settings **only** when both halves are
+ * known — a `build` script (which gives the command) and a recognised framework
+ * with a fixed default publish directory (which gives the output). Anything else
+ * returns `null`, leaving the zip without a synthesised `[build]` table so
+ * buildbot's own framework detection resolves the settings instead. That matters
+ * because a `[build]` table with a command but no `publish` makes buildbot
+ * publish the deploy root — shipping the project's *source* rather than its
+ * built output, which is worse than not guessing at all.
+ *
+ * Returns `null` too when the drop already declares a `[build]` table: the
+ * author's own config always wins.
+ */
+export declare function inferBuildSettings(files: ProcessedFile[]): InferredBuildSettings | null;

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

@@ -1,68 +1,95 @@
-const u = /* @__PURE__ */ new Set([
-  "astro",
-  "next",
-  "nuxt",
-  "gatsby",
-  "vite",
-  "react-scripts",
-  "parcel",
-  "expo",
-  "gridsome",
-  "vuepress",
-  "hexo",
-  "@remix-run/dev",
-  "@sveltejs/kit",
-  "@angular/cli",
-  "@vue/cli-service",
-  "@11ty/eleventy",
-  "@docusaurus/core",
-  "@builder.io/qwik",
-  "@analogjs/platform",
-  "@solidjs/start"
-]), c = /^\s*\[build(\.[\w-]+)?\]/m, d = ["/netlify/functions/", "/netlify/edge-functions/"], l = new TextDecoder();
-function i(e, n) {
-  return e.find((t) => t.path === n);
+const l = /* @__PURE__ */ new Map([
+  ["astro", "dist"],
+  ["next", ".next"],
+  ["nuxt", null],
+  ["gatsby", "public"],
+  ["vite", "dist"],
+  ["react-scripts", "build"],
+  ["parcel", "dist"],
+  ["expo", "dist"],
+  ["gridsome", "dist"],
+  ["vuepress", null],
+  ["hexo", "public"],
+  ["@remix-run/dev", null],
+  ["@sveltejs/kit", null],
+  ["@angular/cli", null],
+  ["@vue/cli-service", "dist"],
+  ["@11ty/eleventy", "_site"],
+  ["@docusaurus/core", "build"],
+  ["@builder.io/qwik", "dist"],
+  ["@analogjs/platform", null],
+  ["@solidjs/start", null]
+]), a = /^\s*\[build(\.[\w-]+)?\]/m, f = ["/netlify/functions/", "/netlify/edge-functions/"], p = new TextDecoder();
+function i(n, e) {
+  return n.find((t) => t.path === e);
 }
-function o(e) {
-  return l.decode(e.content);
+function o(n) {
+  return p.decode(n.content);
 }
-function a(e) {
-  const n = e.scripts;
-  if (!n || typeof n != "object") return !1;
-  const t = n.build;
+function s(n) {
+  const e = n.scripts;
+  if (!e || typeof e != "object") return !1;
+  const t = e.build;
   return typeof t == "string" && t.trim().length > 0;
 }
-function f(e) {
-  for (const n of ["dependencies", "devDependencies"]) {
-    const t = e[n];
+function c(n) {
+  for (const e of ["dependencies", "devDependencies"]) {
+    const t = n[e];
     if (!(!t || typeof t != "object")) {
       for (const r of Object.keys(t))
-        if (u.has(r)) return !0;
+        if (l.has(r)) return r;
     }
   }
-  return !1;
+  return null;
 }
-function p(e) {
-  const n = i(e, "/netlify.toml");
-  if (n && c.test(o(n)))
+function b(n) {
+  return c(n) !== null;
+}
+function g(n) {
+  const e = i(n, "/netlify.toml");
+  if (e && a.test(o(e)))
     return { buildRequired: !0, reason: "netlify-toml-build" };
-  const t = i(e, "/package.json");
+  const t = d(n);
   if (t) {
-    let r = null;
-    try {
-      r = JSON.parse(o(t));
-    } catch {
-      r = null;
-    }
-    if (r) {
-      if (a(r))
-        return { buildRequired: !0, reason: "package-json-build-script" };
-      if (f(r))
-        return { buildRequired: !0, reason: "framework-dependency" };
-    }
+    if (s(t))
+      return { buildRequired: !0, reason: "package-json-build-script" };
+    if (b(t))
+      return { buildRequired: !0, reason: "framework-dependency" };
   }
-  return e.some((r) => d.some((s) => r.path.startsWith(s))) ? { buildRequired: !0, reason: "functions-directory" } : { buildRequired: !1, reason: null };
+  return n.some((r) => f.some((u) => r.path.startsWith(u))) ? { buildRequired: !0, reason: "functions-directory" } : { buildRequired: !1, reason: null };
+}
+function d(n) {
+  const e = i(n, "/package.json");
+  if (!e) return null;
+  try {
+    return JSON.parse(o(e));
+  } catch {
+    return null;
+  }
+}
+const m = [
+  ["/pnpm-lock.yaml", "pnpm"],
+  ["/yarn.lock", "yarn"],
+  ["/bun.lockb", "bun"],
+  ["/bun.lock", "bun"],
+  ["/package-lock.json", "npm"]
+], y = /^\s*\[build\]/m;
+function k(n) {
+  for (const [e, t] of m)
+    if (i(n, e)) return t;
+  return "npm";
+}
+function E(n) {
+  const e = i(n, "/netlify.toml");
+  if (e && y.test(o(e))) return null;
+  const t = d(n);
+  if (!t || !s(t)) return null;
+  const r = c(t);
+  if (!r) return null;
+  const u = l.get(r);
+  return u ? { command: `${k(n)} run build`, publish: u, framework: r } : null;
 }
 export {
-  p as detectBuild
+  g as detectBuild,
+  E as inferBuildSettings
 };

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

@@ -8,6 +8,44 @@
 export declare class UnsupportedDropError extends Error {
     constructor();
 }
+/**
+ * Thrown when an authenticated path (static or build) turns out to have no
+ * usable session — the short-lived upload token came back empty, or the
+ * session-cookie site create was refused, so nothing was created. For static
+ * drops the flow falls back to the anonymous drop + claim; builds have no
+ * anonymous equivalent, so the consumer's only recourse is to send the visitor
+ * through login/signup and have them drop again.
+ */
+export declare class NotAuthenticatedError extends Error {
+    constructor(message?: string);
+}
+/** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
+export declare class SiteCreateError extends Error {
+    status?: number;
+    constructor(status?: number);
+}
+/**
+ * The multipart `POST /sites/{id}/builds` upload itself failed — the build never
+ * started. Distinct from `BuildFailedError`, which is a build that ran and broke.
+ */
+export declare class BuildCreateError extends Error {
+    status?: number;
+    constructor(status?: number);
+}
+/**
+ * The build ran and ended in `error`/`rejected`. `reason` is the API's
+ * `error_message` when there is one — it's the only part of a build failure that
+ * says anything actionable (a failing build command, a missing dependency), so
+ * it is surfaced to the user rather than swallowed.
+ */
+export declare class BuildFailedError extends Error {
+    reason?: string | undefined;
+    constructor(reason?: string | undefined);
+}
+/** The build hadn't settled before the poller gave up. The build itself may still finish. */
+export declare class BuildTimeoutError extends Error {
+    constructor();
+}
 /**
  * Turn a raw deploy failure into copy a non-technical user can act on.
  * The original message is still tracked via analytics — this is only for display.

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

@@ -1,12 +1,52 @@
-class n extends Error {
+var n = Object.defineProperty;
+var i = (e, t, r) => t in e ? n(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var a = (e, t, r) => i(e, typeof t != "symbol" ? t + "" : t, r);
+class o extends Error {
   constructor() {
     super("unsupported single file"), this.name = "UnsupportedDropError";
   }
 }
-function a(e) {
+class s extends Error {
+  constructor(t = "not authenticated") {
+    super(t), this.name = "NotAuthenticatedError";
+  }
+}
+class u extends Error {
+  constructor(r) {
+    super(`site create failed${r ? `: ${r}` : ""}`);
+    a(this, "status");
+    this.name = "SiteCreateError", this.status = r;
+  }
+}
+class f extends Error {
+  constructor(r) {
+    super(`build create failed${r ? `: ${r}` : ""}`);
+    a(this, "status");
+    this.name = "BuildCreateError", this.status = r;
+  }
+}
+class l extends Error {
+  constructor(t) {
+    super(t ? `build failed: ${t}` : "build failed"), this.reason = t, this.name = "BuildFailedError";
+  }
+}
+class d extends Error {
+  constructor() {
+    super("Build did not finish in time"), this.name = "BuildTimeoutError";
+  }
+}
+function h(e) {
   if (!(e instanceof Error)) return "Something went wrong. Please try again.";
-  if (e instanceof n)
+  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.";
+  if (e instanceof u)
+    return "We couldn't create a project for this build. Please try again.";
+  if (e instanceof l)
+    return e.reason ? `Your build failed: ${e.reason}` : "Your build failed. Check your build settings and try again.";
+  if (e instanceof d)
+    return "Your build is taking longer than expected. It may still finish — check your Netlify dashboard.";
   if (e.message === "Deploy did not become ready in time")
     return "Your site is taking longer than expected to go live. Please try again in a moment.";
   if (e instanceof TypeError)
@@ -32,6 +72,11 @@ function a(e) {
   }
 }
 export {
-  n as UnsupportedDropError,
-  a as humanizeDropError
+  f as BuildCreateError,
+  l as BuildFailedError,
+  d as BuildTimeoutError,
+  s as NotAuthenticatedError,
+  u as SiteCreateError,
+  o as UnsupportedDropError,
+  h as humanizeDropError
 };

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

@@ -0,0 +1,17 @@
+/**
+ * Distinct MIME types across a drop or file-picker selection, sorted so the same
+ * selection always yields the same array.
+ *
+ * Read from the raw `File.type` at the drop boundary rather than from
+ * `ProcessedFile`s: the MIME type only exists on the original `File`, and reading
+ * can throw before any `ProcessedFile` does (an unsupported single file) — the
+ * very case the file type is most worth knowing about.
+ *
+ * Browsers leave `File.type` empty for anything they don't recognise — a dragged
+ * folder, an `.exe`, an extensionless file — so those collapse to
+ * `application/octet-stream` and the property never carries an empty string.
+ *
+ * Call this synchronously inside the drop handler: a `DataTransfer` detaches once
+ * the event turn ends.
+ */
+export declare function getFileTypes(files: FileList | null | undefined): string[];

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

@@ -0,0 +1,11 @@
+const n = "application/octet-stream";
+function e(t) {
+  if (!(t != null && t.length)) return [];
+  const r = /* @__PURE__ */ new Set();
+  for (const o of Array.from(t))
+    r.add(o.type || n);
+  return Array.from(r).sort().slice(0, 20);
+}
+export {
+  e as getFileTypes
+};

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

@@ -1,7 +1,11 @@
 export * from './types';
 export * from './digest';
 export * from './readFiles';
+export * from './fileTypes';
 export * from './detectBuild';
 export * from './client';
+export * from './authedDropClient';
+export * from './buildClient';
+export * from './zip';
 export * from './deploy';
 export * from './errors';