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

package/packages/drop-core/buildStash.ts

@@ -0,0 +1,185 @@
+import type { 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.
+ */
+
+export interface DropBuildStash {
+  /** The `source.zip` exactly as it would have been uploaded. */
+  zipFile: File;
+  /** Settings synthesised into the archive's netlify.toml, if any. */
+  buildSettings: InferredBuildSettings | null;
+  createdAt: number;
+}
+
+const DB_NAME = 'netlify-drop';
+const DB_VERSION = 1;
+const STORE_NAME = 'build-stash';
+const STASH_KEY = 'latest';
+const MARKER_KEY = 'dropBuildStash';
+const STASH_TTL_MS = 24 * 60 * 60 * 1000;
+const OPERATION_TIMEOUT_MS = 3000;
+const MAX_ZIP_BYTES = 200 * 1024 * 1024;
+/** Only stash when the quota comfortably fits the zip — never wedge the origin's storage. */
+const QUOTA_HEADROOM = 2;
+
+const withTimeout = <T>(promise: Promise<T>): Promise<T> =>
+  Promise.race([
+    promise,
+    new Promise<never>((_resolve, reject) => {
+      setTimeout(() => reject(new Error('IndexedDB operation timed out')), OPERATION_TIMEOUT_MS);
+    }),
+  ]);
+
+const openDatabase = (): Promise<IDBDatabase> =>
+  new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION);
+    request.onupgradeneeded = () => {
+      request.result.createObjectStore(STORE_NAME);
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+
+// One request per transaction; awaiting mid-transaction would auto-commit it.
+const runStoreOperation = <T>(
+  mode: IDBTransactionMode,
+  makeRequest: (store: IDBObjectStore) => IDBRequest<T>
+): Promise<T> =>
+  withTimeout(
+    openDatabase().then(
+      db =>
+        new Promise<T>((resolve, reject) => {
+          const request = makeRequest(db.transaction(STORE_NAME, mode).objectStore(STORE_NAME));
+          request.onsuccess = () => {
+            db.close();
+            resolve(request.result);
+          };
+          request.onerror = () => {
+            db.close();
+            reject(request.error);
+          };
+        })
+    )
+  );
+
+const hasEnoughQuota = async (bytes: number): Promise<boolean> => {
+  const { quota, usage } = await navigator.storage.estimate();
+  return quota !== undefined && usage !== undefined && quota - usage > bytes * QUOTA_HEADROOM;
+};
+
+// The marker is a plain localStorage flag with its own expiry, so page loads can
+// ask "is there anything to resume?" synchronously without opening IndexedDB.
+const setMarker = () => {
+  localStorage.setItem(MARKER_KEY, JSON.stringify({ expiresAt: Date.now() + STASH_TTL_MS }));
+};
+
+const clearMarker = () => {
+  localStorage.removeItem(MARKER_KEY);
+};
+
+/**
+ * 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.
+ */
+export async function saveDropStash(
+  zipFile: File,
+  buildSettings: InferredBuildSettings | null = null
+): Promise<boolean> {
+  try {
+    if (
+      typeof indexedDB === 'undefined' ||
+      !navigator.storage?.estimate ||
+      zipFile.size > MAX_ZIP_BYTES ||
+      !(await hasEnoughQuota(zipFile.size))
+    ) {
+      return false;
+    }
+    const record: DropBuildStash = { zipFile, buildSettings, createdAt: Date.now() };
+    await runStoreOperation('readwrite', store => store.put(record, STASH_KEY));
+    setMarker();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The stashed drop, or null when there is none, it expired, or storage is unavailable. */
+export async function loadDropStash(): Promise<DropBuildStash | null> {
+  try {
+    if (typeof indexedDB === 'undefined') return null;
+    const record = await runStoreOperation<DropBuildStash | undefined>('readonly', store =>
+      store.get(STASH_KEY)
+    );
+    const zipFile = record && rehydrateZipFile(record.zipFile);
+    if (!record || !zipFile) return null;
+    if (Date.now() - record.createdAt > STASH_TTL_MS) {
+      await clearDropStash();
+      return null;
+    }
+    return { ...record, zipFile };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The archive back out of storage as a real `File`. Structured clone should
+ * preserve File identity, but implementations vary in whether the name and
+ * prototype survive — and the build upload needs both (the multipart field is
+ * named by the File). A Blob-shaped survivor is rewrapped; anything else is
+ * treated as a corrupt record.
+ */
+function rehydrateZipFile(stored: unknown): File | null {
+  if (stored instanceof File && stored.name) return stored;
+  if (stored instanceof Blob || (stored && typeof (stored as Blob).arrayBuffer === 'function')) {
+    return new File([stored as Blob], 'source.zip', { type: 'application/zip' });
+  }
+  return null;
+}
+
+/** Remove the stash and its marker. Idempotent; never throws. */
+export async function clearDropStash(): Promise<void> {
+  try {
+    clearMarker();
+  } catch {
+    // storage disabled — nothing to clear
+  }
+  try {
+    if (typeof indexedDB === 'undefined') return;
+    await runStoreOperation('readwrite', store => store.delete(STASH_KEY));
+  } catch {
+    // best effort — an orphaned record expires via its TTL
+  }
+}
+
+/** Cheap synchronous check so page loads don't open IndexedDB just to look for a stash. */
+export function hasDropStashMarker(): boolean {
+  try {
+    const marker = localStorage.getItem(MARKER_KEY);
+    if (!marker) return false;
+    const { expiresAt } = JSON.parse(marker) as { expiresAt?: number };
+    if (typeof expiresAt !== 'number' || Date.now() > expiresAt) {
+      clearMarker();
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}

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

@@ -0,0 +1,135 @@
+import { describe, expect, it, vi } from 'vitest';
+import { deployBuild, deployFiles } from './deploy';
+import type { BuildClient } from './buildClient';
+import type { DropClient } from './client';
+import type { DeployProgress, ProcessedFile } from './types';
+
+const encoder = new TextEncoder();
+
+const file = (path: string, sha: string, contents = 'x'): ProcessedFile => {
+  const content = encoder.encode(contents).buffer as ArrayBuffer;
+  return { path, sha, content, size: content.byteLength, name: path.split('/').pop()! };
+};
+
+const files = [file('/index.html', 'aaa'), file('/site.css', 'bbb'), file('/app.js', 'ccc')];
+
+function stubDropClient(required: string[]) {
+  const uploaded: string[] = [];
+  let inFlight = 0;
+  let maxInFlight = 0;
+  const client: DropClient = {
+    getToken: vi.fn(async () => 'tok'),
+    createDeploy: vi.fn(async () => ({
+      id: 'site',
+      deploy_id: 'deploy',
+      subdomain: 'sub',
+      required,
+    })),
+    uploadFile: vi.fn(async (deployId: string, path: string) => {
+      inFlight++;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await new Promise(r => setTimeout(r, 2));
+      uploaded.push(`${deployId}:${path}`);
+      inFlight--;
+    }),
+    waitUntilReady: vi.fn(async () => {}),
+  };
+  return { client, uploaded, maxConcurrent: () => maxInFlight };
+}
+
+describe('deployFiles', () => {
+  it('uploads only the SHAs the backend reported missing, keyed by deploy_id', async () => {
+    const { client, uploaded } = stubDropClient(['aaa', 'ccc']);
+    const result = await deployFiles(client, files);
+    expect(uploaded.sort()).toEqual(['deploy:/app.js', 'deploy:/index.html']);
+    expect(result.url).toBe('https://sub.netlify.app');
+    expect(result.token).toBe('tok');
+    expect(client.waitUntilReady).toHaveBeenCalledWith(
+      expect.objectContaining({ deploy_id: 'deploy' }),
+      'tok'
+    );
+  });
+
+  it('never runs more than five uploads at once', async () => {
+    const many = Array.from({ length: 20 }, (_, i) => file(`/f${i}.txt`, `sha${i}`));
+    const { client, maxConcurrent } = stubDropClient(many.map(f => f.sha));
+    await deployFiles(client, many);
+    expect(maxConcurrent()).toBeLessThanOrEqual(5);
+  });
+
+  it('reports progress through the full phase sequence', async () => {
+    const { client } = stubDropClient(['aaa']);
+    const phases: DeployProgress[] = [];
+    await deployFiles(client, files, { onProgress: e => phases.push(e) });
+    expect(phases.map(p => p.phase)).toEqual([
+      'creating',
+      'uploading',
+      'uploading',
+      'processing',
+      'ready',
+    ]);
+    expect(phases[1]).toEqual({ phase: 'uploading', uploaded: 0, total: 1 });
+  });
+
+  it('throws on an empty file set before any network call', async () => {
+    const { client } = stubDropClient([]);
+    await expect(deployFiles(client, [])).rejects.toThrow('No files to deploy');
+    expect(client.getToken).not.toHaveBeenCalled();
+  });
+});
+
+describe('deployBuild', () => {
+  const stubBuildClient = (): BuildClient & { calls: string[] } => {
+    const calls: string[] = [];
+    return {
+      calls,
+      createSite: vi.fn(async () => (calls.push('createSite'), { id: 'site', name: 'sub' })),
+      createBuildFromZip: vi.fn(
+        async () => (calls.push('createBuildFromZip'), { id: 'b', deploy_id: 'd' })
+      ),
+      waitUntilBuildReady: vi.fn(async () => {
+        calls.push('waitUntilBuildReady');
+      }),
+    };
+  };
+
+  it('zips, creates the site, uploads, and reports the site URL', async () => {
+    const client = stubBuildClient();
+    const result = await deployBuild(client, files);
+    expect(result.site.name).toBe('sub');
+    expect(result.build.deploy_id).toBe('d');
+    expect(result.url).toBe('https://sub.netlify.app');
+    // Off by default: the useful hand-off is the project page, not a spinner.
+    expect(client.waitUntilBuildReady).not.toHaveBeenCalled();
+  });
+
+  it('zips BEFORE creating the site, so a failed zip leaves no empty project behind', async () => {
+    const client = stubBuildClient();
+    // An empty file set makes zipFiles throw before any client call.
+    await expect(deployBuild(client, [])).rejects.toThrow('No files to deploy');
+    expect(client.createSite).not.toHaveBeenCalled();
+  });
+
+  it('waits for the build only when asked', async () => {
+    const client = stubBuildClient();
+    await deployBuild(client, files, { waitForBuild: true });
+    expect(client.calls).toEqual(['createSite', 'createBuildFromZip', 'waitUntilBuildReady']);
+  });
+
+  it('reports progress through the build phase sequence', async () => {
+    const client = stubBuildClient();
+    const phases: string[] = [];
+    await deployBuild(client, files, { onProgress: e => phases.push(e.phase) });
+    expect(phases).toEqual(['zipping', 'creating', 'uploading', 'building', 'ready']);
+  });
+
+  it('falls back through ssl_url → url → derived netlify.app domain', async () => {
+    const client = stubBuildClient();
+    (client.createSite as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: 's',
+      name: 'sub',
+      url: 'http://custom.example',
+    });
+    expect((await deployBuild(client, files)).url).toBe('http://custom.example');
+  });
+});

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

@@ -3,7 +3,7 @@ import type { BuildClient, BuildResponse, BuildSite } from './buildClient';
 import type { DropClient } from './client';
 import type { InferredBuildSettings } from './detectBuild';
 import type { DeployProgress, DeployResult, ProcessedFile } from './types';
-import { zipFiles } from './zip';
+import { zipFiles, type ZipResult } from './zip';
 
 const MAX_CONCURRENT_UPLOADS = 5;
 
@@ -95,10 +95,24 @@ export async function deployBuild(
   opts: BuildDeployOptions = {}
 ): Promise<BuildDeployResult> {
   if (!files.length) throw new Error('No files to deploy');
-  const { onProgress, waitForBuild = false } = opts;
 
-  onProgress?.({ phase: 'zipping' });
-  const { file: zip, buildSettings } = await zipFiles(files);
+  opts.onProgress?.({ phase: 'zipping' });
+  const archive = await zipFiles(files);
+
+  return deployZippedBuild(client, archive, opts);
+}
+
+/**
+ * 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.
+ */
+export async function deployZippedBuild(
+  client: BuildClient,
+  { file: zip, buildSettings }: ZipResult,
+  opts: BuildDeployOptions = {}
+): Promise<BuildDeployResult> {
+  const { onProgress, waitForBuild = false } = opts;
 
   onProgress?.({ phase: 'creating' });
   const site = await client.createSite();

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';