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

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

@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest';
+import { detectBuild, inferBuildSettings } from './detectBuild';
+import type { ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+
+const file = (path: string, contents = ''): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, content, size: content.byteLength, sha: 'test-sha', name: path.split('/').pop()! };
+};
+
+const packageJson = (json: object) => file('/package.json', JSON.stringify(json));
+const staticSite = () => [file('/index.html', '<h1>hi</h1>'), file('/style.css', 'body{}')];
+
+describe('detectBuild', () => {
+  it('treats a plain static site as deployable without a build', () => {
+    expect(detectBuild(staticSite())).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a netlify.toml [build] table', () => {
+    const files = [
+      ...staticSite(),
+      file('/netlify.toml', '[build]\n  command = "npm run build"\n'),
+    ];
+    expect(detectBuild(files)).toEqual({ buildRequired: true, reason: 'netlify-toml-build' });
+  });
+
+  it('counts [build] sub-tables like [build.environment]', () => {
+    const files = [...staticSite(), file('/netlify.toml', '[build.environment]\n  FOO = "1"\n')];
+    expect(detectBuild(files)).toEqual({ buildRequired: true, reason: 'netlify-toml-build' });
+  });
+
+  it('ignores a [build] mention inside a comment', () => {
+    const files = [
+      ...staticSite(),
+      file('/netlify.toml', '# [build] used to live here\n[[redirects]]\n'),
+    ];
+    expect(detectBuild(files)).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a package.json build script', () => {
+    const files = [...staticSite(), packageJson({ scripts: { build: 'vite build' } })];
+    expect(detectBuild(files)).toEqual({
+      buildRequired: true,
+      reason: 'package-json-build-script',
+    });
+  });
+
+  it('does not count an empty build script', () => {
+    const files = [...staticSite(), packageJson({ scripts: { build: '  ' } })];
+    expect(detectBuild(files)).toEqual({ buildRequired: false, reason: null });
+  });
+
+  it('requires a build for a known framework dependency, prod or dev', () => {
+    expect(detectBuild([packageJson({ dependencies: { astro: '^4.0.0' } })])).toEqual({
+      buildRequired: true,
+      reason: 'framework-dependency',
+    });
+    expect(detectBuild([packageJson({ devDependencies: { vite: '^6.0.0' } })])).toEqual({
+      buildRequired: true,
+      reason: 'framework-dependency',
+    });
+  });
+
+  it('requires a build for the zero-config functions directories', () => {
+    expect(
+      detectBuild([...staticSite(), file('/netlify/functions/hello.ts', 'export {}')])
+    ).toEqual({
+      buildRequired: true,
+      reason: 'functions-directory',
+    });
+    expect(
+      detectBuild([...staticSite(), file('/netlify/edge-functions/hello.ts', 'export {}')])
+    ).toEqual({ buildRequired: true, reason: 'functions-directory' });
+  });
+
+  it('falls through on a malformed package.json rather than guessing', () => {
+    expect(detectBuild([...staticSite(), file('/package.json', '{ not json')])).toEqual({
+      buildRequired: false,
+      reason: null,
+    });
+  });
+
+  it('reports the first matching signal when several apply', () => {
+    const files = [
+      file('/netlify.toml', '[build]\n'),
+      packageJson({ scripts: { build: 'x' }, dependencies: { astro: '1' } }),
+    ];
+    expect(detectBuild(files).reason).toBe('netlify-toml-build');
+  });
+});
+
+describe('inferBuildSettings', () => {
+  const buildable = (extra: object = {}) =>
+    packageJson({ scripts: { build: 'astro build' }, dependencies: { astro: '^4' }, ...extra });
+
+  it('returns command + publish + framework when both halves are known', () => {
+    expect(inferBuildSettings([buildable()])).toEqual({
+      command: 'npm run build',
+      publish: 'dist',
+      framework: 'astro',
+    });
+  });
+
+  it('names the package manager from the lockfile', () => {
+    expect(inferBuildSettings([buildable(), file('/pnpm-lock.yaml')])?.command).toBe(
+      'pnpm run build'
+    );
+    expect(inferBuildSettings([buildable(), file('/yarn.lock')])?.command).toBe('yarn run build');
+    expect(inferBuildSettings([buildable(), file('/bun.lock')])?.command).toBe('bun run build');
+  });
+
+  it('defers to an existing [build] table — the author config wins', () => {
+    expect(
+      inferBuildSettings([buildable(), file('/netlify.toml', '[build]\n  publish = "out"\n')])
+    ).toBeNull();
+  });
+
+  it('still synthesises when the toml has only sub-tables (no [build] itself)', () => {
+    expect(
+      inferBuildSettings([buildable(), file('/netlify.toml', '[build.environment]\n  A = "1"\n')])
+    ).not.toBeNull();
+  });
+
+  it('returns null without a build script — no command to state', () => {
+    expect(inferBuildSettings([packageJson({ dependencies: { astro: '^4' } })])).toBeNull();
+  });
+
+  it('returns null for frameworks whose publish directory is not a fixed default', () => {
+    // Guessing publish wrong ships source instead of output — worse than not guessing.
+    expect(
+      inferBuildSettings([packageJson({ scripts: { build: 'x' }, dependencies: { nuxt: '^3' } })])
+    ).toBeNull();
+  });
+
+  it('returns null when no known framework is present', () => {
+    expect(inferBuildSettings([packageJson({ scripts: { build: 'make site' } })])).toBeNull();
+  });
+});

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

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { getDigest } from './digest';
+import type { ProcessedFile } from './types';
+
+const file = (path: string, sha: string): ProcessedFile => ({
+  path,
+  sha,
+  size: 0,
+  content: new ArrayBuffer(0),
+  name: path.split('/').pop()!,
+});
+
+describe('getDigest', () => {
+  it('maps each path to its sha', () => {
+    expect(getDigest([file('/index.html', 'aaa'), file('/css/site.css', 'bbb')])).toEqual({
+      '/index.html': 'aaa',
+      '/css/site.css': 'bbb',
+    });
+  });
+
+  it('returns an empty digest for an empty file set', () => {
+    expect(getDigest([])).toEqual({});
+  });
+});

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

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { apiError } from './client';
+import {
+  BuildCreateError,
+  BuildFailedError,
+  BuildTimeoutError,
+  humanizeDropError,
+  NotAuthenticatedError,
+  SiteCreateError,
+  UnsupportedDropError,
+} from './errors';
+
+describe('humanizeDropError', () => {
+  it('maps each typed error to its user-facing copy', () => {
+    expect(humanizeDropError(new UnsupportedDropError())).toBe(
+      'To deploy, drop a folder or a .zip file — or a single HTML page.'
+    );
+    expect(humanizeDropError(new SiteCreateError(500))).toBe(
+      "We couldn't create a project for this build. Please try again."
+    );
+    expect(humanizeDropError(new BuildTimeoutError())).toBe(
+      'Your build is taking longer than expected. It may still finish — check your Netlify dashboard.'
+    );
+  });
+
+  it("passes a failed build's own message through — the only actionable part", () => {
+    expect(humanizeDropError(new BuildFailedError('Command failed: npm run build'))).toBe(
+      'Your build failed: Command failed: npm run build'
+    );
+    expect(humanizeDropError(new BuildFailedError())).toBe(
+      'Your build failed. Check your build settings and try again.'
+    );
+  });
+
+  it('maps API statuses attached by apiError()', () => {
+    expect(humanizeDropError(apiError('drop', 429))).toContain('Too many attempts');
+    expect(humanizeDropError(apiError('upload /x', 413))).toContain('too large');
+    expect(humanizeDropError(apiError('poll', 404))).toContain("couldn't find that deploy");
+    expect(humanizeDropError(apiError('drop', 401))).toContain("wasn't allowed");
+    expect(humanizeDropError(apiError('drop', 503))).toContain('servers are having trouble');
+  });
+
+  it('routes typed errors carrying a status through the same mapping', () => {
+    expect(humanizeDropError(new BuildCreateError(413))).toContain('too large');
+  });
+
+  it('maps the shared deploy-timeout message', () => {
+    expect(humanizeDropError(new Error('Deploy did not become ready in time'))).toContain(
+      'taking longer than expected'
+    );
+  });
+
+  it('reads a fetch TypeError as a connectivity problem', () => {
+    expect(humanizeDropError(new TypeError('Failed to fetch'))).toContain(
+      'Check your internet connection'
+    );
+  });
+
+  it('falls back to generic copy for anything else', () => {
+    expect(humanizeDropError('not even an error')).toBe('Something went wrong. Please try again.');
+    expect(humanizeDropError(new Error('mystery'))).toBe('Something went wrong. Please try again.');
+  });
+
+  it('keeps the NotAuthenticatedError copy path-agnostic — it gates static deploys and builds alike', () => {
+    expect(humanizeDropError(new NotAuthenticatedError())).toBe(
+      'Please log in to Netlify to deploy this project, then try again.'
+    );
+  });
+});

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

@@ -85,7 +85,7 @@ export function humanizeDropError(err: unknown): string {
   }
 
   if (err instanceof NotAuthenticatedError) {
-    return 'Please log in to Netlify to deploy a project that needs a build, then try again.';
+    return 'Please log in to Netlify to deploy this project, then try again.';
   }
 
   if (err instanceof SiteCreateError) {

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import { getFileTypes } from './fileTypes';
+
+/** Minimal FileList stand-in — getFileTypes only touches length and iteration. */
+const fileList = (...types: string[]): FileList => {
+  const files = types.map((type, i) => new File(['x'], `f${i}`, { type }));
+  return Object.assign(files, { item: (i: number) => files[i] }) as unknown as FileList;
+};
+
+describe('getFileTypes', () => {
+  it('returns [] when the browser exposes no files', () => {
+    expect(getFileTypes(null)).toEqual([]);
+    expect(getFileTypes(undefined)).toEqual([]);
+    expect(getFileTypes(fileList())).toEqual([]);
+  });
+
+  it('dedupes and sorts so the same selection always yields the same array', () => {
+    expect(getFileTypes(fileList('text/html', 'image/png', 'text/html', 'text/css'))).toEqual([
+      'image/png',
+      'text/css',
+      'text/html',
+    ]);
+  });
+
+  it('reports application/octet-stream for files the browser could not type', () => {
+    // A dragged folder or an .exe arrives with an empty File.type.
+    expect(getFileTypes(fileList(''))).toEqual(['application/octet-stream']);
+  });
+
+  it('caps the list at 20 distinct types', () => {
+    const many = Array.from(
+      { length: 30 },
+      (_, i) => `application/x-${String(i).padStart(2, '0')}`
+    );
+    expect(getFileTypes(fileList(...many))).toHaveLength(20);
+  });
+});

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

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

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.js

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