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

package/packages/drop-core/readFiles.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { zip } from 'fflate';
+import {
+  getSingleNonIndexHtmlFileName,
+  hasMultipleHtmlFilesWithoutIndex,
+  readFileList,
+  renameSingleNonIndexHtmlToIndex,
+} from './readFiles';
+import { UnsupportedDropError } from './errors';
+import type { ProcessedFile } from './types';
+
+// `readDataTransfer` is deliberately untested: it rides the webkit FileSystem
+// entries API (webkitGetAsEntry / createReader), which no test DOM implements.
+// Its FileList fallback and zip branch share the code paths covered below.
+
+const encoder = new TextEncoder();
+
+const processed = (path: string, name = path.split('/').pop()!): ProcessedFile => ({
+  path,
+  name,
+  size: 1,
+  sha: 'test-sha',
+  content: encoder.encode('x').buffer as ArrayBuffer,
+});
+
+/** A File carrying the relative path a directory-picker <input> would report. */
+const pickedFile = (relativePath: string, contents = 'x'): File => {
+  const f = new File([contents], relativePath.split('/').pop()!);
+  Object.defineProperty(f, 'webkitRelativePath', { value: relativePath });
+  return f;
+};
+
+const asFileList = (files: File[]): FileList =>
+  Object.assign(files, { item: (i: number) => files[i] }) as unknown as FileList;
+
+const zipBytes = (entries: Record<string, string>): Promise<Uint8Array> =>
+  new Promise((resolve, reject) => {
+    const encoded: Record<string, Uint8Array> = {};
+    for (const [path, contents] of Object.entries(entries))
+      encoded[path] = encoder.encode(contents);
+    zip(encoded, (err, out) => (err ? reject(err) : resolve(out)));
+  });
+
+describe('readFileList', () => {
+  it('reads a folder selection into root-relative ProcessedFiles', async () => {
+    const files = await readFileList(
+      asFileList([pickedFile('site/index.html', '<h1>hi</h1>'), pickedFile('site/css/site.css')])
+    );
+    // The common root folder is stripped so config sits at the deploy root.
+    expect(files.map(f => f.path).sort()).toEqual(['/css/site.css', '/index.html']);
+    expect(files[0].sha).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  it('does not strip a shared folder when a file sits beside it at the root', async () => {
+    const files = await readFileList(
+      asFileList([pickedFile('index.html'), pickedFile('assets/app.js')])
+    );
+    expect(files.map(f => f.path).sort()).toEqual(['/assets/app.js', '/index.html']);
+  });
+
+  it('rejects a single loose file that is neither a zip nor an HTML page', async () => {
+    await expect(readFileList(asFileList([pickedFile('photo.png')]))).rejects.toBeInstanceOf(
+      UnsupportedDropError
+    );
+  });
+
+  it('allows a lone HTML page to stand alone', async () => {
+    const files = await readFileList(asFileList([pickedFile('page.html', '<p>solo</p>')]));
+    expect(files).toHaveLength(1);
+    expect(files[0].path).toBe('/page.html');
+  });
+
+  it('expands a single dropped zip, skipping directories and junk entries', async () => {
+    const bytes = await zipBytes({
+      'my-site/index.html': '<h1>zipped</h1>',
+      'my-site/__MACOSX/._index.html': 'resource fork',
+      'my-site/.DS_Store': 'junk',
+      'my-site/node_modules/pkg/index.js': 'dep',
+      'my-site/css/site.css': 'body{}',
+    });
+    const files = await readFileList(
+      asFileList([new File([bytes.buffer.slice(0) as ArrayBuffer], 'my-site.zip')])
+    );
+    // Junk gone, common "my-site/" root stripped.
+    expect(files.map(f => f.path).sort()).toEqual(['/css/site.css', '/index.html']);
+  });
+});
+
+describe('index.html helpers', () => {
+  it('names the lone non-index HTML file, and only that case', () => {
+    expect(getSingleNonIndexHtmlFileName([processed('/about.html'), processed('/a.css')])).toBe(
+      'about.html'
+    );
+    expect(
+      getSingleNonIndexHtmlFileName([processed('/index.html'), processed('/about.html')])
+    ).toBeNull();
+    expect(getSingleNonIndexHtmlFileName([processed('/a.html'), processed('/b.html')])).toBeNull();
+    expect(getSingleNonIndexHtmlFileName([processed('/a.css')])).toBeNull();
+  });
+
+  it('flags multiple HTML files with no index', () => {
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/a.html'), processed('/b.html')])).toBe(
+      true
+    );
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/index.html'), processed('/b.html')])).toBe(
+      false
+    );
+    expect(hasMultipleHtmlFilesWithoutIndex([processed('/a.html')])).toBe(false);
+  });
+
+  it('renames the lone HTML page to index.html in place, keeping its directory', () => {
+    const input = [processed('/docs/about.html'), processed('/docs/site.css')];
+    const renamed = renameSingleNonIndexHtmlToIndex(input);
+    const page = renamed.find(f => f.name === 'index.html')!;
+    expect(page.path).toBe('/docs/index.html');
+    // Content and sha untouched — only the served path changes.
+    expect(page.sha).toBe(input[0].sha);
+    expect(page.content).toBe(input[0].content);
+  });
+
+  it('leaves sets with an index, several pages, or no HTML unchanged', () => {
+    const withIndex = [processed('/index.html'), processed('/about.html')];
+    expect(renameSingleNonIndexHtmlToIndex(withIndex)).toBe(withIndex);
+  });
+});

package/packages/{components/preact/DropZone/drop-core → drop-core}/types.ts

@@ -40,15 +40,21 @@ export interface DeployResult {
  * zipping → creating → uploading → building → ready.
  */
 export type DeployPhase =
-  | 'zipping'
-  | 'creating'
-  | 'uploading'
-  | 'processing'
-  | 'building'
-  | 'ready';
+  'zipping' | 'creating' | 'uploading' | 'processing' | 'building' | 'ready';
 
 export interface DeployProgress {
   phase: DeployPhase;
   uploaded?: number;
   total?: number;
 }
+
+/** 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;
+}

package/packages/drop-core/zip.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { unzip } from 'fflate';
+import { generateNetlifyToml, zipFiles } from './zip';
+import type { ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+const file = (path: string, contents = 'x'): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, content, size: content.byteLength, sha: 'test-sha', name: path.split('/').pop()! };
+};
+
+const buildableProject = () => [
+  file('/index.html', '<h1>hi</h1>'),
+  file(
+    '/package.json',
+    JSON.stringify({ scripts: { build: 'astro build' }, dependencies: { astro: '^4' } })
+  ),
+];
+
+const unzipArchive = async (archive: File): Promise<Record<string, string>> => {
+  const bytes = new Uint8Array(await archive.arrayBuffer());
+  const entries = await new Promise<Record<string, Uint8Array>>((resolve, reject) =>
+    unzip(bytes, (err, data) => (err ? reject(err) : resolve(data)))
+  );
+  return Object.fromEntries(Object.entries(entries).map(([k, v]) => [k, decoder.decode(v)]));
+};
+
+describe('generateNetlifyToml', () => {
+  it('renders only command and publish — everything else stays zero-config', () => {
+    expect(
+      generateNetlifyToml({ command: 'npm run build', publish: 'dist', framework: 'astro' })
+    ).toBe('[build]\n  command = "npm run build"\n  publish = "dist"\n');
+  });
+
+  it('escapes TOML basic-string metacharacters', () => {
+    const toml = generateNetlifyToml({ command: 'echo "a\\b"', publish: 'dist', framework: 'x' });
+    expect(toml).toContain('command = "echo \\"a\\\\b\\""');
+  });
+});
+
+describe('zipFiles', () => {
+  it('throws on an empty file set', async () => {
+    await expect(zipFiles([])).rejects.toThrow('No files to deploy');
+  });
+
+  it('zips files with archive-root-relative paths (no leading slash)', async () => {
+    const { file: archive, buildSettings } = await zipFiles([file('/index.html', '<h1>hi</h1>')]);
+    expect(archive.name).toBe('source.zip');
+    expect(archive.type).toBe('application/zip');
+    expect(buildSettings).toBeNull(); // nothing inferable for a static site
+    expect(await unzipArchive(archive)).toEqual({ 'index.html': '<h1>hi</h1>' });
+  });
+
+  it('synthesises a netlify.toml when settings are inferable', async () => {
+    const { file: archive, buildSettings } = await zipFiles(buildableProject());
+    expect(buildSettings).toEqual({
+      command: 'npm run build',
+      publish: 'dist',
+      framework: 'astro',
+    });
+    const entries = await unzipArchive(archive);
+    expect(entries['netlify.toml']).toContain('[build]');
+    expect(entries['netlify.toml']).toContain('publish = "dist"');
+  });
+
+  it('appends to an existing netlify.toml so redirects and headers survive', async () => {
+    const existing = '[[redirects]]\n  from = "/old"\n  to = "/new"\n';
+    const { file: archive } = await zipFiles([
+      ...buildableProject(),
+      file('/netlify.toml', existing),
+    ]);
+    const toml = (await unzipArchive(archive))['netlify.toml'];
+    expect(toml).toContain('[[redirects]]');
+    expect(toml).toContain('[build]');
+    expect(toml.indexOf('[[redirects]]')).toBeLessThan(toml.indexOf('[build]'));
+  });
+
+  it('uploads the drop untouched when synthesizeNetlifyToml is off', async () => {
+    const { file: archive, buildSettings } = await zipFiles(buildableProject(), {
+      synthesizeNetlifyToml: false,
+    });
+    expect(buildSettings).toBeNull();
+    expect((await unzipArchive(archive))['netlify.toml']).toBeUndefined();
+  });
+
+  it('honors a custom archive name', async () => {
+    const { file: archive } = await zipFiles([file('/index.html')], { name: 'drop.zip' });
+    expect(archive.name).toBe('drop.zip');
+  });
+});

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

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

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

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

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

@@ -1,92 +0,0 @@
-var h = Object.defineProperty;
-var d = (n, t, o) => t in n ? h(n, t, { enumerable: !0, configurable: !0, writable: !0, value: o }) : n[t] = o;
-var r = (n, t, o) => d(n, typeof t != "symbol" ? t + "" : t, o);
-import { NotAuthenticatedError as l, SiteCreateError as c, BuildCreateError as p, BuildFailedError as u, BuildTimeoutError as w } from "./errors.js";
-const f = "https://api.netlify.com/api/v1", m = 1e3, y = 10 * 60 * 1e3, B = /* @__PURE__ */ new Set(["ready", "error", "rejected"]);
-class g {
-  constructor({
-    apiBase: t = f,
-    getUploadToken: o,
-    accountSlug: e,
-    title: s = "Build from drop deployment",
-    pollIntervalMs: i = m,
-    timeoutMs: a = y
-  }) {
-    r(this, "apiBase");
-    r(this, "getUploadToken");
-    r(this, "accountSlug");
-    r(this, "title");
-    r(this, "pollIntervalMs");
-    r(this, "timeoutMs");
-    this.apiBase = t, this.getUploadToken = o, this.accountSlug = e, this.title = s, this.pollIntervalMs = i, this.timeoutMs = a;
-  }
-  /**
-   * Create the site the build deploys into. Authorized by the bearer token;
-   * without an account slug the API picks the user's default account.
-   */
-  async createSite() {
-    const t = await this.getUploadToken();
-    if (!t) throw new l();
-    const o = this.accountSlug ? `/${this.accountSlug}/sites` : "/sites", e = await fetch(`${this.apiBase}${o}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${t}` },
-      body: JSON.stringify({ created_via: "drop" })
-    });
-    if (e.status === 401 || e.status === 403) throw new l();
-    if (!e.ok) throw new c(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, o) {
-    const e = await this.getUploadToken();
-    if (!e) throw new l();
-    const s = new FormData();
-    s.append("zip", o), s.append("title", this.title);
-    const i = await fetch(`${this.apiBase}/sites/${t}/builds`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${e}` },
-      body: s
-    });
-    if (i.status === 401 || i.status === 403) throw new l();
-    if (!i.ok) throw new p(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, 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.
-   */
-  async waitUntilBuildReady(t) {
-    if (!t.deploy_id) return;
-    const o = this.timeoutMs / this.pollIntervalMs;
-    for (let e = 0; e < o; e++) {
-      const s = await this.getUploadToken(), i = await fetch(`${this.apiBase}/deploys/${t.deploy_id}`, {
-        headers: s ? { Authorization: `Bearer ${s}` } : {}
-      });
-      if (i.ok) {
-        const a = await i.json();
-        if (a.state && B.has(a.state)) {
-          if (a.state === "ready") return;
-          throw new u(a.error_message);
-        }
-      }
-      await new Promise((a) => setTimeout(a, this.pollIntervalMs));
-    }
-    throw new w();
-  }
-}
-export {
-  g as AuthenticatedBuildClient
-};

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

@@ -1,48 +0,0 @@
-import { getDigest as w } from "./digest.js";
-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(f, u.length) }, c));
-}
-async function s(i, l, n = {}) {
-  if (!l.length) throw new Error("No files to deploy");
-  const { onProgress: t } = n;
-  t == null || t({ phase: "creating" });
-  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),
-    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 deployBuild,
-  s as deployFiles
-};

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

@@ -1,36 +0,0 @@
-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,
-  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
-};