@netlify/spark-ui 1.31.0-alpha.5 → 1.31.0-alpha.6

package/dist/drop-core/buildClient.js

@@ -1,16 +1,16 @@
-var u = Object.defineProperty;
-var d = (r, t, e) => t in r ? u(r, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : r[t] = e;
-var o = (r, t, e) => d(r, typeof t != "symbol" ? t + "" : t, e);
+var d = Object.defineProperty;
+var u = (i, t, e) => t in i ? d(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var o = (i, t, e) => u(i, typeof t != "symbol" ? t + "" : t, e);
 import { createSiteInAccount as c, pollDeployUntilSettled as h } from "./authedApi.js";
 import { DEFAULT_PROXY_BASE as m, DEFAULT_API_BASE as B, DEFAULT_POLL_INTERVAL_MS as y, DEFAULT_TIMEOUT_MS as w } from "./constants.js";
-import { NotAuthenticatedError as l, BuildCreateError as f, BuildFailedError as A, BuildTimeoutError as E } from "./errors.js";
-class U {
+import { BuildCreateError as l, BuildFailedError as M, BuildTimeoutError as T } from "./errors.js";
+class _ {
   constructor({
     proxyBase: t = m,
     apiBase: e = B,
     getUploadToken: a,
-    accountSlug: s,
-    title: i = "Build from drop deployment",
+    accountSlug: r,
+    title: s = "Build from drop deployment",
     pollIntervalMs: n = y,
     timeoutMs: p = w
   }) {
@@ -21,52 +21,39 @@ class U {
     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 = p;
+    this.proxyBase = t, this.apiBase = e, this.getUploadToken = a, this.accountSlug = r, this.title = s, this.pollIntervalMs = n, this.timeoutMs = p;
   }
-  /**
-   * 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.
-   */
+  /** A logged-out visitor fails here, before anything is created (see `createSiteInAccount`). */
   async createSite() {
     return c(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.
+   * One multipart request on a fresh 30s bearer — a slower zip fails mid-flight
+   * (the app origin gets 300s; raising ours is a platform-side change).
+   * Content-Type stays unset so the browser adds the multipart boundary.
    *
-   * 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.
+   * Never NotAuthenticatedError, including for a 401: the site exists by the
+   * time this runs, so signalling "no session" would strand it and re-stash
+   * the drop for the next visit to strand another. `createSite` is the auth
+   * gate for this path.
    */
   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`, {
+    const r = new FormData();
+    r.append("zip", e), r.append("title", this.title);
+    const s = await fetch(`${this.apiBase}/sites/${t}/builds`, {
       method: "POST",
       headers: { Authorization: `Bearer ${a}` },
-      body: s
+      body: r
     });
-    if (i.status === 401 || i.status === 403) throw new l();
-    if (!i.ok) throw new f(i.status);
-    return i.json();
+    if (!s.ok) throw new l(s.status);
+    return s.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.
+   * Optional (a build takes minutes; the useful hand-off is the project page).
+   * Polls on the cookie, so it can't outlive its credentials; no deploy id yet
+   * means nothing pollable, so it resolves immediately.
    */
   async waitUntilBuildReady(t) {
     if (!t.deploy_id) return;
@@ -77,9 +64,9 @@ class U {
       timeoutMs: this.timeoutMs
     });
     if (e.outcome !== "ready")
-      throw e.outcome === "failed" ? new A(e.errorMessage) : new E();
+      throw e.outcome === "failed" ? new M(e.errorMessage) : new T();
   }
 }
 export {
-  U as AuthenticatedBuildClient
+  _ as AuthenticatedBuildClient
 };

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

@@ -1,20 +1,10 @@
 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.
+ * Carries a build drop across the signup round-trip: stash the zip in
+ * IndexedDB before the hand-off, deploy it when the visitor returns
+ * authenticated. Storage is per-origin by design — the hand-off must bring
+ * them back here. Every operation swallows failures: no storage means the
+ * plain signup redirect the zone always supported.
  */
 export interface DropBuildStash {
     /** The `source.zip` exactly as it would have been uploaded. */
@@ -23,11 +13,7 @@ export interface DropBuildStash {
     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.
- */
+/** Stash the archive for auto-deploy after signup. The result phrases the hand-off, never blocks 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>;

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

@@ -11,7 +11,7 @@ export interface DropClient {
 }
 /**
  * Unauthenticated drop client. Authorized server-side by the Referer header,
- * so it only works from an allowlisted origin (see backend checklist).
+ * so it only works from an allowlisted origin.
  */
 export declare class AnonymousDropClient implements DropClient {
     private apiBase;

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

@@ -1,29 +1,9 @@
-/**
- * The tunables shared across drop-core, one place and one comment each.
- * Module-specific constants (e.g. buildStash's storage caps) stay with their
- * module; anything two modules read belongs here.
- */
-/**
- * Root for session-cookie JSON calls, via the consumer's access-control
- * rewrite. On netlify.com, `/access-control/*` targets the app's
- * access-control function; the paths an origin may call are allowlisted
- * server-side.
- */
+/** Tunables shared across drop-core. Module-specific constants stay with their module. */
 export declare const DEFAULT_PROXY_BASE = "/access-control/bb-api/api/v1";
 /** Direct api.netlify.com root for the uploads the proxy's ~6MB Lambda body limit can't carry. */
 export declare const DEFAULT_API_BASE = "https://api.netlify.com/api/v1";
 export declare const DEFAULT_POLL_INTERVAL_MS = 1000;
 export declare const DEFAULT_TIMEOUT_MS: number;
 export declare const MAX_CONCURRENT_UPLOADS = 5;
-/**
- * How long a minted upload token is reused before minting another: 20 seconds.
- * The server issues non-app origins a 30s token; the gap leaves margin for the
- * request the token authorizes to finish.
- */
 export declare const TOKEN_REUSE_MS: number;
-/**
- * Waits between attempts of a failed file upload, as data so the whole curve
- * can be overridden (the tus-js-client `retryDelays` idiom). Three retries,
- * linear backoff; 400/422 responses never retry — see `uploadWithRetry`.
- */
 export declare const UPLOAD_RETRY_DELAYS_MS: readonly number[];

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

@@ -10,7 +10,6 @@ export interface DeployOptions {
 }
 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;
@@ -21,26 +20,15 @@ export interface BuildDeployResult {
 }
 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.
+     * Wait for the build instead of returning at enqueue. Off by default (builds
+     * take minutes); on is the only way a BuildFailedError reaches the caller.
      */
     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.
+ * Zip the drop, create a site, hand buildbot the archive. Zipping comes first
+ * on purpose: a failed zip must not leave an empty site behind.
  */
 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.
- */
+/** Deploy an already-zipped archive — the resume path for a stashed drop (see `buildStash`). */
 export declare function deployZippedBuild(client: BuildClient, { file: zip, buildSettings }: ZipResult, opts?: BuildDeployOptions): Promise<BuildDeployResult>;

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

@@ -2,23 +2,15 @@ import { ProcessedFile } from './types';
 /** Why a drop was judged to need a build — surfaced to analytics and `onBuildRequired`. */
 export type BuildReason = 'netlify-toml-build' | 'package-json-build-script' | 'framework-dependency' | 'functions-directory';
 export interface BuildDetection {
-    /** True when the dropped project needs a build step and can't be served as static files. */
+    /** The drop can't be served as static files. */
     buildRequired: boolean;
     /** The signal that decided it (first match wins), or null for a plain static drop. */
     reason: BuildReason | null;
 }
 /**
- * Decide whether a dropped project needs a build. Runs on the already-read,
- * root-normalized `ProcessedFile[]` (a dropped `.zip` is expanded and the common
- * root folder stripped upstream in `readFiles`), so build config sits at the
- * deploy root, e.g. `/netlify.toml`, `/package.json`.
- *
- * The anonymous drop API only performs static deploys, so a build-required
- * project can't go through it — the consumer redirects such drops to the
- * authenticated Drop page instead. This heuristic is deliberately lightweight
- * (no framework-detection dependency): it reads the two config files and looks
- * for the zero-config functions directories. A plain static site (HTML/CSS/JS,
- * no build config) returns `{ buildRequired: false }`.
+ * Does this drop need a build? Deliberately lightweight (two config files +
+ * the functions dirs; no framework-detection dependency). Input is
+ * root-normalized by `readFiles`, so config sits at `/netlify.toml` etc.
  */
 export declare function detectBuild(files: ProcessedFile[]): BuildDetection;
 /** Build settings confident enough to write into a `netlify.toml` for buildbot. */
@@ -31,19 +23,9 @@ export interface InferredBuildSettings {
     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.
+ * Build settings for the synthesised netlify.toml — only when BOTH halves are
+ * known (build script → command, known framework → publish). Guessing publish
+ * wrong ships source instead of output, so `null` beats a bad guess. An
+ * author-declared [build] table always wins (also `null`).
  */
 export declare function inferBuildSettings(files: ProcessedFile[]): InferredBuildSettings | null;

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

@@ -1,33 +1,22 @@
 /**
- * Thrown when the user drops or picks a single loose file that Drop can't turn
- * into a site on its own — anything that isn't a `.zip` (a site archive) or an
- * HTML page (served as index.html). A folder, multiple files, a zip, or a lone
- * HTML file are all fine; any other single file is rejected rather than
- * deployed as a one-asset site (matches react-ui).
+ * A single loose file that can't stand up a site — only a zip, folder,
+ * multiple files, or a lone HTML page may deploy (matches react-ui).
  */
 export declare class UnsupportedDropError extends Error {
     readonly code = "unsupported-drop";
     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.
+ * The pre-mutation "no session" signal: nothing was created yet, so static
+ * drops may fall back to the anonymous flow and build drops stash + hand off.
  */
 export declare class NotAuthenticatedError extends Error {
     readonly code = "not-authenticated";
     constructor(message?: string);
 }
 /**
- * Whether an error is the pre-mutation "no session" signal, however it
- * traveled. This package ships as both raw TypeScript (`./components`) and
- * compiled dist (`./preact`, `./drop-core`), so two copies of the class can
- * coexist in one app and defeat `instanceof` — the `code` brand is the
- * copy-proof fallback. Control flow that decides whether an anonymous retry
- * is safe must use this, never a bare `instanceof`.
+ * Copy-proof check for the "no session" error — `instanceof` misses class
+ * copies from the package's other entrypoint. Fallback gates must use this.
  */
 export declare function isNotAuthenticatedError(err: unknown): err is NotAuthenticatedError;
 /** `POST …/sites` failed, so there is nothing to build into. Carries the HTTP status. */
@@ -45,12 +34,7 @@ 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.
- */
+/** The build ran and broke. `reason` carries the API's `error_message` — the only actionable part. */
 export declare class BuildFailedError extends Error {
     reason?: string | undefined;
     readonly code = "build-failed";
@@ -61,10 +45,7 @@ export declare class BuildTimeoutError extends Error {
     readonly code = "build-timeout";
     constructor();
 }
-/**
- * A static deploy ran and ended in `error`/`rejected`. Like a build failure,
- * the API's `error_message` is the actionable part, so it travels on the error.
- */
+/** A static deploy ran and ended in `error`/`rejected`; `reason` carries the API's `error_message`. */
 export declare class DeployFailedError extends Error {
     reason?: string | undefined;
     readonly code = "deploy-failed";

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

@@ -1,17 +1,7 @@
 /**
- * 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.
+ * Distinct, sorted MIME types of a selection. Read at the drop boundary — the
+ * type only exists on the original File, and reading can throw before any
+ * ProcessedFile exists. Call synchronously in the drop handler: a DataTransfer
+ * detaches after the event turn.
  */
 export declare function getFileTypes(files: FileList | null | undefined): string[];

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

@@ -1,21 +1,15 @@
 import { ProcessedFile } from './types';
 /**
- * Read a DataTransfer from a drop event into ProcessedFiles.
- *
- * NOTE: `webkitGetAsEntry()` must be called synchronously inside the drop
- * handler — the DataTransfer is detached once the event turn ends. The
- * component captures entries first (see `readDroppedEntries`) then calls the
- * async readers, so this function is safe to `await`.
+ * Read a drop's DataTransfer into ProcessedFiles. `webkitGetAsEntry()` runs
+ * synchronously before the first await — the DataTransfer detaches once the
+ * event turn ends.
  */
 export declare function readDataTransfer(dt: DataTransfer): Promise<ProcessedFile[]>;
 export declare function readFileList(files: FileList): Promise<ProcessedFile[]>;
 export declare function getSingleNonIndexHtmlFileName(files: ProcessedFile[]): string | null;
 export declare function hasMultipleHtmlFilesWithoutIndex(files: ProcessedFile[]): boolean;
 /**
- * When the set has no index.html but exactly one HTML file (a lone page
- * alongside its assets, or a single dropped file), rename that file to
- * index.html — keeping its directory — so it is served at the site root
- * instead of 404ing. Content and sha are untouched. Any other set (already has
- * an index, multiple HTML files, or no HTML) is returned unchanged.
+ * A lone non-index HTML page is renamed to index.html (same directory,
+ * content/sha untouched) so it serves instead of 404ing. Other sets unchanged.
  */
 export declare function renameSingleNonIndexHtmlToIndex(files: ProcessedFile[]): ProcessedFile[];

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

@@ -9,10 +9,8 @@ export interface ProcessedFile {
 }
 export type Digest = Record<string, string>;
 /**
- * Response body of `POST /api/v1/drop`. Not a canonical Deploy resource —
- * it's a mixed shape carrying both the anonymous site and the initial deploy
- * so the client has everything it needs to upload, poll, and hand off to the
- * user in one round trip.
+ * Response of `POST /api/v1/drop` — a mixed site+deploy shape, everything the
+ * client needs to upload, poll, and hand off in one round trip.
  */
 export interface DropResponse {
     /** site id (UUID) — surfaced to callers so they can build claim links */

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

@@ -1,46 +1,23 @@
 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.
- */
+/** Renders a [build] table — command and publish only; everything else is zero-config server-side. */
 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.
-     */
+    /** Synthesise a [build] table when the drop lacks one (default true); false uploads as-dropped. */
     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.
-     */
+    /** Settings written into netlify.toml, or null when the archive is a faithful copy. */
     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.
+ * Zip a read file set into the archive `POST /sites/{id}/builds` expects.
+ * Junk is already gone (readFiles); dist/build are deliberately kept — a drop
+ * publishing a committed directory without a command would break without them.
+ * A [build] table is synthesised when missing (appended, so redirects survive).
  */
 export declare function zipFiles(files: ProcessedFile[], { name, synthesizeNetlifyToml }?: ZipOptions): Promise<ZipResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@netlify/spark-ui",
   "description": "Assets, design tokens, components, and utilities",
-  "version": "1.31.0-alpha.5",
+  "version": "1.31.0-alpha.6",
   "type": "module",
   "main": "dist/components/preact/index.js",
   "types": "dist/components/preact/index.d.ts",