@netlify/spark-ui 1.25.0 → 1.26.0-alpha.2

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

@@ -0,0 +1,55 @@
+import { getDigest, getShas } from './digest';
+import type { DropClient } from './client';
+import type { DeployProgress, DeployResult, ProcessedFile } from './types';
+
+const MAX_CONCURRENT_UPLOADS = 5;
+
+async function uploadRequired(
+  client: DropClient,
+  deployId: string,
+  files: ProcessedFile[],
+  required: Set<string>,
+  token: string,
+  onUploaded?: (uploaded: number) => void
+) {
+  const queue = files.filter(f => required.has(f.sha));
+  let cursor = 0;
+  let done = 0;
+  const worker = async () => {
+    while (cursor < queue.length) {
+      const f = queue[cursor++];
+      await client.uploadFile(deployId, f.path, f.content, token);
+      onUploaded?.(++done);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(MAX_CONCURRENT_UPLOADS, queue.length) }, worker));
+}
+
+export interface DeployOptions {
+  onProgress?: (e: DeployProgress) => void;
+}
+
+export async function deployFiles(
+  client: DropClient,
+  files: ProcessedFile[],
+  opts: DeployOptions = {}
+): Promise<DeployResult> {
+  if (!files.length) throw new Error('No files to deploy');
+  const { onProgress } = opts;
+
+  onProgress?.({ phase: 'creating' });
+  const token = await client.getToken();
+  const deploy = await client.createDeploy(getDigest(files), token);
+
+  const total = deploy.required.length;
+  onProgress?.({ phase: 'uploading', uploaded: 0, total });
+  await uploadRequired(client, deploy.id, files, getShas(deploy.required), token, uploaded =>
+    onProgress?.({ phase: 'uploading', uploaded, total })
+  );
+
+  onProgress?.({ phase: 'processing' });
+  await client.waitUntilReady(deploy, token);
+
+  onProgress?.({ phase: 'ready' });
+  return { deploy, token, url: `https://${deploy.subdomain}.netlify.app` };
+}

package/packages/components/preact/DropZone/drop-core/digest.ts

@@ -0,0 +1,11 @@
+import type { Digest, ProcessedFile } from './types';
+
+export function getDigest(files: ProcessedFile[]): Digest {
+  const digest: Digest = {};
+  for (const f of files) digest[f.path] = f.sha;
+  return digest;
+}
+
+export function getShas(required: string[]): Set<string> {
+  return new Set(required);
+}

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

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './digest';
+export * from './readFiles';
+export * from './client';
+export * from './deploy';

package/packages/components/preact/DropZone/drop-core/readFiles.ts

@@ -0,0 +1,136 @@
+import Rusha from 'rusha';
+import type { ProcessedFile } from './types';
+
+/* eslint-disable @typescript-eslint/no-explicit-any -- webkit FileSystem entry APIs are untyped */
+
+const rusha = new Rusha();
+
+const IGNORED = (name: string) =>
+  name.startsWith('.') || name === '__MACOSX' || name === 'node_modules';
+
+const slashPrefix = (p: string) => (p.startsWith('/') ? p : `/${p}`);
+
+function toProcessedFile(path: string, content: ArrayBuffer, name: string): ProcessedFile {
+  return {
+    path: slashPrefix(path),
+    size: content.byteLength,
+    sha: rusha.digest(content),
+    content,
+    name,
+  };
+}
+
+// --- folder drop (webkit entries) -------------------------------------------
+
+async function readFileEntry(entry: any): Promise<ProcessedFile> {
+  const file: File = await new Promise((res, rej) => entry.file(res, rej));
+  const content = await file.arrayBuffer();
+  return toProcessedFile(entry.fullPath, content, file.name);
+}
+
+async function readDirEntry(entry: any): Promise<ProcessedFile[]> {
+  const reader = entry.createReader();
+  const out: ProcessedFile[] = [];
+  // readEntries yields in batches; loop until empty
+  for (;;) {
+    const batch: any[] = await new Promise((res, rej) => reader.readEntries(res, rej));
+    if (!batch.length) break;
+    for (const child of batch) {
+      if (IGNORED(child.name)) continue;
+      out.push(...(child.isDirectory ? await readDirEntry(child) : [await readFileEntry(child)]));
+    }
+  }
+  return out;
+}
+
+/**
+ * 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`.
+ */
+export async function readDataTransfer(dt: DataTransfer): Promise<ProcessedFile[]> {
+  // single zip?
+  const first = dt.files?.[0];
+  if (dt.files.length === 1 && first && /\.zip$/i.test(first.name)) {
+    return readZip(first);
+  }
+  const items = Array.from(dt.items ?? []);
+  const entries = items.map(i => i.webkitGetAsEntry?.()).filter(Boolean) as any[];
+  if (entries.length) {
+    const nested = await Promise.all(
+      entries.map(e =>
+        IGNORED(e.name) ? [] : e.isDirectory ? readDirEntry(e) : readFileEntry(e).then(f => [f])
+      )
+    );
+    return normalizeFiles(nested.flat());
+  }
+  // fallback: plain FileList (e.g. multi-file <input>)
+  return readFileList(dt.files);
+}
+
+// --- <input type=file> ------------------------------------------------------
+
+export async function readFileList(files: FileList): Promise<ProcessedFile[]> {
+  const list = Array.from(files);
+  if (list.length === 1 && /\.zip$/i.test(list[0].name)) {
+    return readZip(list[0]);
+  }
+  const out: ProcessedFile[] = [];
+  for (const file of list) {
+    const rel = (file as any).webkitRelativePath || file.name;
+    out.push(toProcessedFile(rel, await file.arrayBuffer(), file.name));
+  }
+  return normalizeFiles(out);
+}
+
+// --- zip --------------------------------------------------------------------
+
+export async function readZip(zip: File): Promise<ProcessedFile[]> {
+  const { unzip } = await import('fflate');
+  const buf = new Uint8Array(await zip.arrayBuffer());
+  const entries = await new Promise<Record<string, Uint8Array>>((resolve, reject) =>
+    unzip(buf, (err, data) => (err ? reject(err) : resolve(data)))
+  );
+  const out: ProcessedFile[] = [];
+  for (const [path, bytes] of Object.entries(entries)) {
+    // fflate uses a trailing slash to signal directory entries; also skip the
+    // usual junk (macOS metadata, dotfiles at any depth).
+    if (path.endsWith('/') || /(^|\/)(__MACOSX\/|\.)/.test(path)) continue;
+    const content = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+    out.push(toProcessedFile(path, content, path.split('/').pop()!));
+  }
+  return normalizeFiles(out);
+}
+
+// --- path normalization (strip the common root folder) ----------------------
+
+export function normalizeFiles(files: ProcessedFile[]): ProcessedFile[] {
+  if (!files.length) return files;
+  const split = (p: string) => slashPrefix(p).split('/').slice(1); // drop leading ''
+  let common = split(files[0].path).slice(0, -1);
+  for (const f of files) {
+    const segs = split(f.path);
+    let i = 0;
+    while (i < common.length && i < segs.length - 1 && common[i] === segs[i]) i++;
+    common = common.slice(0, i);
+  }
+  if (!common.length) return files;
+  const prefix = '/' + common.join('/');
+  return files.map(f => ({ ...f, path: slashPrefix(f.path.slice(prefix.length)) }));
+}
+
+// --- index.html validation (UI can surface these as warnings) ---------------
+
+export function getSingleNonIndexHtmlFileName(files: ProcessedFile[]): string | null {
+  const html = files.filter(f => /\.html?$/i.test(f.name));
+  if (html.some(f => /^index\.html?$/i.test(f.name))) return null;
+  return html.length === 1 ? html[0].name : null;
+}
+
+export function hasMultipleHtmlFilesWithoutIndex(files: ProcessedFile[]): boolean {
+  const html = files.filter(f => /\.html?$/i.test(f.name));
+  return html.length > 1 && !html.some(f => /^index\.html?$/i.test(f.name));
+}

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

@@ -0,0 +1,35 @@
+export interface ProcessedFile {
+  /** POSIX path relative to the deploy root, leading slash, e.g. "/index.html" */
+  path: string;
+  size: number;
+  /** lowercase hex SHA-1 of the file content */
+  sha: string;
+  content: ArrayBuffer;
+  name: string;
+}
+
+export type Digest = Record<string, string>; // { "/index.html": "<sha1>" }
+
+export interface Deploy {
+  id: string;
+  /** the *.netlify.app subdomain assigned to the anonymous site */
+  subdomain: string;
+  /** SHAs the backend does NOT yet have — only these get uploaded */
+  required: string[];
+  state?: string;
+}
+
+export interface DeployResult {
+  deploy: Deploy;
+  /** drop token — persist this to later claim the site into an account */
+  token: string;
+  url: string; // https://<subdomain>.netlify.app
+}
+
+export type DeployPhase = 'creating' | 'uploading' | 'processing' | 'ready';
+
+export interface DeployProgress {
+  phase: DeployPhase;
+  uploaded?: number;
+  total?: number;
+}