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

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

@@ -1,21 +1,36 @@
-import { getDigest as o } from "./digest.js";
-import { getSingleNonIndexHtmlFileName as l, hasMultipleHtmlFilesWithoutIndex as n, readDataTransfer as p, readFileList as i, renameSingleNonIndexHtmlToIndex as m } from "./readFiles.js";
-import { getFileTypes as d } from "./fileTypes.js";
-import { detectBuild as s } from "./detectBuild.js";
-import { AnonymousDropClient as g } from "./client.js";
-import { deployFiles as D } from "./deploy.js";
-import { UnsupportedDropError as I, humanizeDropError as h } from "./errors.js";
+import { getDigest as t } from "./digest.js";
+import { getSingleNonIndexHtmlFileName as i, hasMultipleHtmlFilesWithoutIndex as l, readDataTransfer as n, readFileList as p, renameSingleNonIndexHtmlToIndex as d } from "./readFiles.js";
+import { getFileTypes as a } from "./fileTypes.js";
+import { detectBuild as x, inferBuildSettings as f } from "./detectBuild.js";
+import { AnonymousDropClient as g, apiError as E } from "./client.js";
+import { AuthenticatedDropClient as F } from "./authedDropClient.js";
+import { AuthenticatedBuildClient as D } from "./buildClient.js";
+import { generateNetlifyToml as C, zipFiles as N } from "./zip.js";
+import { deployBuild as c, deployFiles as A } from "./deploy.js";
+import { BuildCreateError as S, BuildFailedError as H, BuildTimeoutError as z, NotAuthenticatedError as L, SiteCreateError as M, UnsupportedDropError as U, humanizeDropError as W } from "./errors.js";
 export {
   g as AnonymousDropClient,
-  I as UnsupportedDropError,
-  D as deployFiles,
-  s as detectBuild,
-  o as getDigest,
-  d as getFileTypes,
-  l as getSingleNonIndexHtmlFileName,
-  n as hasMultipleHtmlFilesWithoutIndex,
-  h as humanizeDropError,
-  p as readDataTransfer,
-  i as readFileList,
-  m as renameSingleNonIndexHtmlToIndex
+  D as AuthenticatedBuildClient,
+  F as AuthenticatedDropClient,
+  S as BuildCreateError,
+  H as BuildFailedError,
+  z as BuildTimeoutError,
+  L as NotAuthenticatedError,
+  M as SiteCreateError,
+  U as UnsupportedDropError,
+  E as apiError,
+  c as deployBuild,
+  A as deployFiles,
+  x as detectBuild,
+  C as generateNetlifyToml,
+  t as getDigest,
+  a as getFileTypes,
+  i as getSingleNonIndexHtmlFileName,
+  l as hasMultipleHtmlFilesWithoutIndex,
+  W as humanizeDropError,
+  f as inferBuildSettings,
+  n as readDataTransfer,
+  p as readFileList,
+  d as renameSingleNonIndexHtmlToIndex,
+  N as zipFiles
 };

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

@@ -579,7 +579,7 @@ async function Q(y) {
   return M(w);
 }
 async function I(y) {
-  const { unzip: m } = await import("../../../../chunks/browser.D58rdxmc.js"), w = new Uint8Array(await y.arrayBuffer()), _ = await new Promise(
+  const { unzip: m } = await import("../../../../chunks/browser.Ca2rTNTu.js"), w = new Uint8Array(await y.arrayBuffer()), _ = await new Promise(
     (v, s) => m(w, (g, u) => g ? s(g) : v(u))
   ), h = [];
   for (const [v, s] of Object.entries(_)) {

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

@@ -30,7 +30,12 @@ export interface DeployResult {
     token: string;
     url: string;
 }
-export type DeployPhase = 'creating' | 'uploading' | 'processing' | 'ready';
+/**
+ * Phases shared by both deploy paths. A static drop runs
+ * creating → uploading → processing → ready; a build drop runs
+ * zipping → creating → uploading → building → ready.
+ */
+export type DeployPhase = 'zipping' | 'creating' | 'uploading' | 'processing' | 'building' | 'ready';
 export interface DeployProgress {
     phase: DeployPhase;
     uploaded?: number;

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

@@ -0,0 +1,46 @@
+import { InferredBuildSettings } from './detectBuild';
+import { ProcessedFile } from './types';
+/**
+ * Render inferred settings as a `[build]` table. Only `command` and `publish`
+ * are written: everything else (functions directory, plugins, node version)
+ * is zero-config on Netlify's side and guessing at it would override detection
+ * that is better informed than we are.
+ */
+export declare function generateNetlifyToml({ command, publish }: InferredBuildSettings): string;
+export interface ZipOptions {
+    /** Filename given to the produced `File`. Shows up as the build's source archive. */
+    name?: string;
+    /**
+     * Synthesise a `netlify.toml` `[build]` table from `inferBuildSettings` when the
+     * drop doesn't declare one (default `true`). Set `false` to upload the files
+     * exactly as dropped and let buildbot resolve every setting itself.
+     */
+    synthesizeNetlifyToml?: boolean;
+}
+export interface ZipResult {
+    /** The archive, ready to hand to `createBuildFromZip`. */
+    file: File;
+    /**
+     * The settings written into `netlify.toml`, or `null` when the archive is a
+     * faithful copy of the drop — either because it already declared a `[build]`
+     * table, or because nothing could be inferred with confidence.
+     */
+    buildSettings: InferredBuildSettings | null;
+}
+/**
+ * Zip an already-read file set into the source archive that
+ * `POST /sites/{id}/builds` expects.
+ *
+ * The input is the same root-normalized `ProcessedFile[]` the static deploy path
+ * uses (see `readFiles`), so junk — dotfiles, `node_modules`, macOS metadata — is
+ * already gone and paths sit at the deploy root. Output directories (`dist/`,
+ * `build/`) are deliberately *not* stripped: buildbot regenerates them when
+ * there's a build command, and a drop whose `netlify.toml` publishes a committed
+ * directory without a command would break if we removed it.
+ *
+ * When the drop needs a build but declares no `[build]` table, an inferred one is
+ * written in (appended to an existing `netlify.toml`, or created if there is
+ * none) so buildbot doesn't publish the project's source. See
+ * `inferBuildSettings` for how conservative that inference is.
+ */
+export declare function zipFiles(files: ProcessedFile[], { name, synthesizeNetlifyToml }?: ZipOptions): Promise<ZipResult>;

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

@@ -0,0 +1,43 @@
+import { inferBuildSettings as d } from "./detectBuild.js";
+const g = "/netlify.toml";
+function a(e) {
+  return e.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function y({ command: e, publish: i }) {
+  return [
+    "[build]",
+    `  command = "${a(e)}"`,
+    `  publish = "${a(i)}"`,
+    ""
+  ].join(`
+`);
+}
+const m = new TextEncoder(), b = new TextDecoder();
+function w(e) {
+  return new Uint8Array(e);
+}
+async function $(e, { name: i = "source.zip", synthesizeNetlifyToml: p = !0 } = {}) {
+  if (!e.length) throw new Error("No files to deploy");
+  const r = p ? d(e) : null, l = {};
+  for (const t of e) {
+    const n = t.path.replace(/^\//, "");
+    n && (l[n] = w(t.content));
+  }
+  if (r) {
+    const t = e.find((s) => s.path === g), n = y(r), c = t ? `${b.decode(t.content).replace(/\n*$/, `
+`)}
+${n}` : n;
+    l["netlify.toml"] = m.encode(c);
+  }
+  const { zip: f } = await import("../../../../chunks/browser.Ca2rTNTu.js"), o = await new Promise(
+    (t, n) => f(l, { level: 6 }, (c, s) => c ? n(c) : t(s))
+  ), u = o.buffer.slice(
+    o.byteOffset,
+    o.byteOffset + o.byteLength
+  );
+  return { file: new File([u], i, { type: "application/zip" }), buildSettings: r };
+}
+export {
+  y as generateNetlifyToml,
+  $ as zipFiles
+};

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

@@ -1,3 +1,4 @@
 export { default as DropZone } from './DropZone';
-export { AnonymousDropClient, deployFiles, detectBuild, getFileTypes, readDataTransfer, readFileList, } from './drop-core';
-export type { BuildDetection, BuildReason, DropClient, DropResponse, Digest, DeployResult, DeployProgress, DeployPhase, ProcessedFile, } from './drop-core';
+export { AnonymousDropClient, AuthenticatedBuildClient, AuthenticatedDropClient, BuildCreateError, BuildFailedError, BuildTimeoutError, deployBuild, deployFiles, detectBuild, getFileTypes, humanizeDropError, inferBuildSettings, NotAuthenticatedError, readDataTransfer, readFileList, SiteCreateError, UnsupportedDropError, zipFiles, } from './drop-core';
+export type { AuthenticatedBuildClientConfig, AuthenticatedDropClientConfig, BuildClient, BuildDeployOptions, BuildDeployResult, BuildDetection, BuildReason, BuildResponse, BuildSite, DropClient, DropResponse, Digest, DeployResult, DeployProgress, DeployPhase, InferredBuildSettings, ProcessedFile, ZipOptions, ZipResult, } from './drop-core';
+export type { DeployedBuild, DeployedSite, DeployError, DeployStatus } from './useDropDeploy';

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

@@ -1,15 +1,31 @@
-import { default as r } from "./DropZone.js";
-import { readDataTransfer as p, readFileList as f } from "./drop-core/readFiles.js";
+import { default as o } from "./DropZone.js";
+import { readDataTransfer as i, readFileList as p } from "./drop-core/readFiles.js";
 import { getFileTypes as l } from "./drop-core/fileTypes.js";
-import { detectBuild as d } from "./drop-core/detectBuild.js";
-import { AnonymousDropClient as s } from "./drop-core/client.js";
-import { deployFiles as n } from "./drop-core/deploy.js";
+import { detectBuild as a, inferBuildSettings as n } from "./drop-core/detectBuild.js";
+import { AnonymousDropClient as m } from "./drop-core/client.js";
+import { AuthenticatedDropClient as s } from "./drop-core/authedDropClient.js";
+import { AuthenticatedBuildClient as E } from "./drop-core/buildClient.js";
+import { zipFiles as C } from "./drop-core/zip.js";
+import { deployBuild as c, deployFiles as h } from "./drop-core/deploy.js";
+import { BuildCreateError as A, BuildFailedError as T, BuildTimeoutError as g, NotAuthenticatedError as z, SiteCreateError as S, UnsupportedDropError as L, humanizeDropError as N } from "./drop-core/errors.js";
 export {
-  s as AnonymousDropClient,
-  r as DropZone,
-  n as deployFiles,
-  d as detectBuild,
+  m as AnonymousDropClient,
+  E as AuthenticatedBuildClient,
+  s as AuthenticatedDropClient,
+  A as BuildCreateError,
+  T as BuildFailedError,
+  g as BuildTimeoutError,
+  o as DropZone,
+  z as NotAuthenticatedError,
+  S as SiteCreateError,
+  L as UnsupportedDropError,
+  c as deployBuild,
+  h as deployFiles,
+  a as detectBuild,
   l as getFileTypes,
-  p as readDataTransfer,
-  f as readFileList
+  N as humanizeDropError,
+  n as inferBuildSettings,
+  i as readDataTransfer,
+  p as readFileList,
+  C as zipFiles
 };

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

@@ -1,12 +1,18 @@
-import { BuildDetection, DropClient, ProcessedFile } from './drop-core';
+import { BuildClient, BuildDetection, DropClient, InferredBuildSettings, ProcessedFile } from './drop-core';
 /** How the files reached the zone — carried through to analytics. */
 export type DeploySource = 'drag' | 'browse';
 /** The live site handed back once a deploy succeeds. */
 export interface DeployedSite {
     url: string;
-    token: string;
+    /**
+     * Drop claim token — only present for anonymous deploys. An authenticated
+     * deploy lands directly in the visitor's account, so there is nothing to claim.
+     */
+    token?: string;
     siteName: string;
     siteId: string;
+    /** True when the deploy landed directly in the visitor's account. */
+    authenticated: boolean;
 }
 /** A deploy failure, handed to `onError` so consumers can render their own error UI. */
 export interface DeployError {
@@ -15,11 +21,25 @@ export interface DeployError {
     /** The raw underlying reason (e.g. "drop failed: 429"), useful for logging. */
     reason: string;
 }
+/** The build handed back once a build-required drop is enqueued. */
+export interface DeployedBuild {
+    /** The site created for the build — live once the build finishes. */
+    url: string;
+    siteName: string;
+    siteId: string;
+    buildId: string;
+    /** The deploy the build produces, if the API has assigned one yet. */
+    deployId?: string;
+    /** Build settings synthesised into the uploaded `netlify.toml`, if any. */
+    buildSettings: InferredBuildSettings | null;
+}
 /** Finite states of a single deploy attempt. */
 export type DeployStatus = {
     kind: 'idle';
 } | {
     kind: 'reading';
+} | {
+    kind: 'zipping';
 } | {
     kind: 'creating';
 } | {
@@ -28,9 +48,11 @@ export type DeployStatus = {
     total: number;
 } | {
     kind: 'processing';
+} | {
+    kind: 'building';
 } | {
     kind: 'redirecting';
-    target: 'claim' | 'signup';
+    target: 'claim' | 'dashboard' | 'signup' | 'build';
 } | {
     kind: 'error';
     message: string;
@@ -41,9 +63,17 @@ interface UseDropDeployOptions {
     apiBase?: string;
     client?: DropClient;
     claimUrl: (siteName: string) => string;
+    siteDashboardUrl: (siteName: string) => string;
     buildSignupUrl: string;
+    buildClient?: BuildClient;
+    authenticatedDropClient?: DropClient;
+    getUploadToken?: () => Promise<string | null>;
+    accountSlug?: string;
+    buildDeployUrl: (build: DeployedBuild) => string;
+    waitForBuild?: boolean;
     onBuildRequired?: (info: BuildDetection) => void;
     onDeploy?: (site: DeployedSite) => void;
+    onBuildDeploy?: (build: DeployedBuild) => void;
     onError?: (error: DeployError) => void;
     track: TrackFn;
 }
@@ -51,7 +81,7 @@ interface UseDropDeployOptions {
  * Owns the deploy state machine and its side effects (upload, local persistence,
  * analytics, redirect), keeping DropZone a thin view over the returned `status`.
  */
-export declare function useDropDeploy({ apiBase, client, claimUrl, buildSignupUrl, onBuildRequired, onDeploy, onError, track, }: UseDropDeployOptions): {
+export declare function useDropDeploy({ apiBase, client, claimUrl, siteDashboardUrl, buildSignupUrl, buildClient, authenticatedDropClient, getUploadToken, accountSlug, buildDeployUrl, waitForBuild, onBuildRequired, onDeploy, onBuildDeploy, onError, track, }: UseDropDeployOptions): {
     status: DeployStatus;
     warning: string | null;
     busy: boolean;

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

@@ -1,95 +1,163 @@
-import { d as y, A as W } from "../../../chunks/hooks.module.DRcxknIz.js";
-import { renameSingleNonIndexHtmlToIndex as $, getSingleNonIndexHtmlFileName as v, hasMultipleHtmlFilesWithoutIndex as A } from "./drop-core/readFiles.js";
-import { detectBuild as C } from "./drop-core/detectBuild.js";
-import { AnonymousDropClient as P } from "./drop-core/client.js";
-import { deployFiles as q } from "./drop-core/deploy.js";
-import { humanizeDropError as M } from "./drop-core/errors.js";
-function T(n) {
-  switch (n.phase) {
+import { d as P, A as I } from "../../../chunks/hooks.module.DRcxknIz.js";
+import { renameSingleNonIndexHtmlToIndex as X, getSingleNonIndexHtmlFileName as Y, hasMultipleHtmlFilesWithoutIndex as Z } from "./drop-core/readFiles.js";
+import { detectBuild as B } from "./drop-core/detectBuild.js";
+import { AnonymousDropClient as D } from "./drop-core/client.js";
+import { AuthenticatedDropClient as T } from "./drop-core/authedDropClient.js";
+import { AuthenticatedBuildClient as U } from "./drop-core/buildClient.js";
+import "./drop-core/zip.js";
+import { deployFiles as H, deployBuild as tt } from "./drop-core/deploy.js";
+import { NotAuthenticatedError as W, humanizeDropError as et } from "./drop-core/errors.js";
+function S(o) {
+  switch (o.phase) {
+    case "zipping":
+      return { kind: "zipping" };
     case "creating":
       return { kind: "creating" };
     case "uploading":
-      return { kind: "uploading", uploaded: n.uploaded ?? 0, total: n.total ?? 0 };
+      return { kind: "uploading", uploaded: o.uploaded ?? 0, total: o.total ?? 0 };
+    case "building":
+      return { kind: "building" };
     case "processing":
     case "ready":
       return { kind: "processing" };
   }
 }
-function j(n) {
-  const l = v(n);
-  return l ? `No index.html found — "${l}" won’t be served at the site root.` : A(n) ? "No index.html found — your site may not have a landing page." : null;
+function nt(o) {
+  const f = Y(o);
+  return f ? `No index.html found — "${f}" won’t be served at the site root.` : Z(o) ? "No index.html found — your site may not have a landing page." : null;
 }
-function O({
-  apiBase: n,
-  client: l,
-  claimUrl: k,
-  buildSignupUrl: w,
-  onBuildRequired: f,
-  onDeploy: u,
-  onError: c,
-  track: s
+function ft({
+  apiBase: o,
+  client: f,
+  claimUrl: $,
+  siteDashboardUrl: v,
+  buildSignupUrl: j,
+  buildClient: q,
+  authenticatedDropClient: M,
+  getUploadToken: m,
+  accountSlug: x,
+  buildDeployUrl: E,
+  waitForBuild: G,
+  onBuildRequired: z,
+  onDeploy: g,
+  onBuildDeploy: h,
+  onError: b,
+  track: c
 }) {
-  const [m, o] = y({ kind: "idle" }), [N, p] = y(null), b = W(l ?? new P(n)).current, x = m.kind !== "idle" && m.kind !== "error";
-  async function I(z, i, h) {
-    p(null), o({ kind: "reading" });
-    const a = h.length ? { file_types: h } : {}, _ = (e, t, d) => {
-      o({ kind: "error", message: e }), s("dropzone_deploy_failed", { method: i, reason: t, ...a, ...d }), c == null || c({ message: e, reason: t });
-    }, F = (e, t) => {
-      const d = e instanceof Error ? e.message : String(e);
-      _(M(e), d, t);
+  const [w, n] = P({ kind: "idle" }), [J, _] = P(null), K = I(f ?? new D(o)).current, C = I(
+    q ?? (m ? new U({ getUploadToken: m, accountSlug: x }) : null)
+  ).current, A = I(
+    M ?? (m ? new T({ getUploadToken: m, accountSlug: x }) : null)
+  ).current, L = w.kind !== "idle" && w.kind !== "error";
+  async function O(y, r) {
+    try {
+      const { site: d, build: l, buildSettings: p, url: k } = await tt(y, r, {
+        onProgress: (t) => n(S(t)),
+        waitForBuild: G
+      });
+      return {
+        url: k,
+        siteName: d.name,
+        siteId: d.id,
+        buildId: l.id,
+        deployId: l.deploy_id,
+        buildSettings: p
+      };
+    } catch (d) {
+      if (d instanceof W) return null;
+      throw d;
+    }
+  }
+  async function Q(y, r, d) {
+    _(null), n({ kind: "reading" });
+    const l = d.length ? { file_types: d } : {}, p = (t, i, a) => {
+      n({ kind: "error", message: t }), c("dropzone_deploy_failed", { method: r, reason: i, ...l, ...a }), b == null || b({ message: t, reason: i });
+    }, k = (t, i) => {
+      const a = t instanceof Error ? t.message : String(t);
+      p(et(t), a, i);
     };
     try {
-      const e = $(await z());
-      if (!e.length) {
-        _("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
+      const t = X(await y());
+      if (!t.length) {
+        p("No files found to deploy.", "No files found to deploy.", { file_count: 0 });
         return;
       }
-      i === "drag" && s("dropzone_files_dropped", {
-        method: i,
-        file_count: e.length,
-        ...a
+      r === "drag" && c("dropzone_files_dropped", {
+        method: r,
+        file_count: t.length,
+        ...l
       });
-      const t = C(e);
-      if (t.buildRequired) {
-        if (s("dropzone_build_required", {
-          method: i,
-          reason: t.reason,
-          file_count: e.length,
-          ...a
-        }), f) {
-          o({ kind: "idle" }), f(t);
+      const i = B(t);
+      if (i.buildRequired) {
+        if (c("dropzone_build_required", {
+          method: r,
+          reason: i.reason,
+          file_count: t.length,
+          ...l
+        }), z) {
+          n({ kind: "idle" }), z(i);
           return;
         }
-        o({ kind: "redirecting", target: "signup" }), window.location.assign(w);
+        if (C) {
+          const e = await O(C, t);
+          if (e) {
+            n({ kind: "redirecting", target: "build" }), c("dropzone_build_deploy_succeeded", {
+              method: r,
+              reason: i.reason,
+              site_name: e.siteName,
+              file_count: t.length,
+              ...e.buildSettings ? { framework: e.buildSettings.framework } : {},
+              ...l
+            }), h == null || h(e), window.location.assign(E(e));
+            return;
+          }
+        }
+        n({ kind: "redirecting", target: "signup" }), window.location.assign(j);
         return;
       }
-      p(j(e));
-      const {
-        url: d,
-        token: g,
-        deploy: r
-      } = await q(b, e, {
-        onProgress: (H) => o(T(H))
-      });
-      try {
-        localStorage.setItem("drop-token", g), localStorage.setItem("dropSiteName", r.subdomain);
-      } catch {
-      }
-      o({ kind: "redirecting", target: "claim" }), s("dropzone_deploy_succeeded", {
-        method: i,
-        site_name: r.subdomain,
-        file_count: e.length,
-        ...a
-      }), u == null || u({ url: d, token: g, siteName: r.subdomain, siteId: r.id }), window.location.assign(`${k(r.subdomain)}#drop_token=${g}`);
-    } catch (e) {
-      F(e);
+      _(nt(t));
+      let a = null, s = !1, F = !1;
+      if (A)
+        try {
+          a = await H(A, t, {
+            onProgress: (e) => n(S(e))
+          }), s = !0;
+        } catch (e) {
+          if (!(e instanceof W)) throw e;
+          F = !0;
+        }
+      a || (a = await H(K, t, {
+        onProgress: (e) => n(S(e))
+      }));
+      const { url: V, token: N, deploy: u } = a;
+      if (!s)
+        try {
+          localStorage.setItem("drop-token", N), localStorage.setItem("dropSiteName", u.subdomain);
+        } catch {
+        }
+      n({ kind: "redirecting", target: s ? "dashboard" : "claim" }), c("dropzone_deploy_succeeded", {
+        method: r,
+        site_name: u.subdomain,
+        file_count: t.length,
+        authenticated: s,
+        ...F ? { auth_fallback: !0 } : {},
+        ...l
+      }), g == null || g({
+        url: V,
+        ...s ? {} : { token: N },
+        siteName: u.subdomain,
+        siteId: u.id,
+        authenticated: s
+      }), s ? window.location.assign(v(u.subdomain)) : window.location.assign(`${$(u.subdomain)}#drop_token=${N}`);
+    } catch (t) {
+      k(t);
     }
   }
-  function S() {
-    p(null), o({ kind: "idle" });
+  function R() {
+    _(null), n({ kind: "idle" });
   }
-  return { status: m, warning: N, busy: x, deploy: I, reset: S };
+  return { status: w, warning: J, busy: L, deploy: Q, reset: R };
 }
 export {
-  O as useDropDeploy
+  ft as useDropDeploy
 };

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

@@ -6,5 +6,6 @@ export { default as SearchHeading } from './SearchModal/components/SearchHeading
 export { default as SearchToggle } from './SearchModal/components/SearchToggle/SearchToggle';
 export { default as AskNetlify } from './AskNetlify/AskNetlify';
 export { SearchModal } from './SearchModal';
-export { DropZone } from './DropZone';
+export { DropZone, AuthenticatedBuildClient, AuthenticatedDropClient } from './DropZone';
+export type { BuildClient, DeployedBuild, DeployedSite, DropClient } from './DropZone';
 export { type IconName } from './Icon';

package/dist/components/preact/index.js

@@ -1,24 +1,29 @@
-import { default as p } from "./KeyboardKey/KeyboardKey.js";
-import { default as d } from "./Modal/Modal.js";
-import { default as s } from "./Icon/index.js";
-import { default as u } from "./SearchModal/components/SearchLink/SearchLink.js";
+import { default as m } from "./KeyboardKey/KeyboardKey.js";
+import { default as l } from "./Modal/Modal.js";
+import { default as u } from "./Icon/index.js";
+import { default as s } from "./SearchModal/components/SearchLink/SearchLink.js";
 import { default as c } from "./SearchModal/components/SearchHeading/SearchHeading.js";
-import { default as n } from "./SearchModal/components/SearchToggle/SearchToggle.js";
+import { default as A } from "./SearchModal/components/SearchToggle/SearchToggle.js";
 import { A as g } from "../../chunks/AskNetlify.bx0blyGV.js";
 import "preact";
 import "../../chunks/hooks.module.DRcxknIz.js";
 import { default as k } from "./SearchModal/components/SearchModal/SearchModal.js";
-import { default as K } from "./DropZone/DropZone.js";
+import { default as D } from "./DropZone/DropZone.js";
 import "./DropZone/drop-core/readFiles.js";
 import "./DropZone/drop-core/detectBuild.js";
+import { AuthenticatedDropClient as M } from "./DropZone/drop-core/authedDropClient.js";
+import { AuthenticatedBuildClient as B } from "./DropZone/drop-core/buildClient.js";
+import "./DropZone/drop-core/zip.js";
 export {
   g as AskNetlify,
-  K as DropZone,
-  s as Icon,
-  p as KeyboardKey,
-  d as Modal,
+  B as AuthenticatedBuildClient,
+  M as AuthenticatedDropClient,
+  D as DropZone,
+  u as Icon,
+  m as KeyboardKey,
+  l as Modal,
   c as SearchHeading,
-  u as SearchLink,
+  s as SearchLink,
   k as SearchModal,
-  n as SearchToggle
+  A as SearchToggle
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/spark-ui",
   "description": "Assets, design tokens, components, and utilities",
-  "version": "1.30.0",
+  "version": "1.31.0-alpha.2",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",
@@ -15,6 +15,7 @@
     "lint:fix": "eslint . --ext .js,.jsx,.ts,.tsx,.astro --fix",
     "format": "prettier --write \"**/*.{js,jsx,ts,tsx,astro,json,css,md,mdx}\" --ignore-path packages/styles/tokens.css",
     "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,astro,json,css,md,mdx}\" --ignore-path packages/styles/tokens.css",
+    "test": "vitest run",
     "prepublishOnly": "npm run build:vite"
   },
   "files": [
@@ -61,6 +62,7 @@
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-astro": "^1.3.1",
     "glob": "^11.0.1",
+    "jsdom": "^30.0.0",
     "preact": "^10.26.4",
     "prettier": "^3.5.3",
     "prettier-plugin-astro": "^0.14.1",
@@ -70,7 +72,8 @@
     "vite": "^6.2.5",
     "vite-plugin-dts": "^4.5.3",
     "vite-plugin-lib-inject-css": "^2.2.1",
-    "vite-tsconfig-paths": "^5.1.4"
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
     "preact": "^10.26.4"