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

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

@@ -0,0 +1,19 @@
+import { Deploy, Digest } from './types';
+export interface DropClient {
+    getToken(): Promise<string>;
+    createDeploy(digest: Digest, token: string): Promise<Deploy>;
+    uploadFile(deployId: string, path: string, content: ArrayBuffer, token: string): Promise<void>;
+    waitUntilReady(deploy: Deploy, token: string): Promise<void>;
+}
+/**
+ * Unauthenticated drop client. Authorized server-side by the Referer header,
+ * so it only works from an allowlisted origin (see backend checklist).
+ */
+export declare class AnonymousDropClient implements DropClient {
+    private apiBase;
+    constructor(apiBase?: string);
+    getToken(): Promise<string>;
+    createDeploy(files: Digest, token: string): Promise<Deploy>;
+    uploadFile(deployId: string, path: string, content: ArrayBuffer, token: string): Promise<void>;
+    waitUntilReady(deploy: Deploy, token: string): Promise<void>;
+}

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

@@ -0,0 +1,41 @@
+const i = "https://api.netlify.com/api/v1";
+class n {
+  constructor(e = i) {
+    this.apiBase = e;
+  }
+  async getToken() {
+    const e = await fetch(`${this.apiBase}/drop/token`, { method: "POST" });
+    if (!e.ok) throw new Error(`drop/token failed: ${e.status}`);
+    return (await e.json()).token;
+  }
+  async createDeploy(e, o) {
+    const t = await fetch(`${this.apiBase}/drop`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ files: e, token: o })
+    });
+    if (!t.ok) throw new Error(`drop failed: ${t.status}`);
+    return t.json();
+  }
+  async uploadFile(e, o, t, a) {
+    const r = await fetch(`${this.apiBase}/deploys/${e}/files${o}`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream", Authorization: `Bearer ${a}` },
+      body: t
+    });
+    if (!r.ok) throw new Error(`upload ${o} failed: ${r.status}`);
+  }
+  async waitUntilReady(e, o) {
+    for (let t = 0; t < 600; t++) {
+      const a = await fetch(`${this.apiBase}/deploys/${e.id}`, {
+        headers: { Authorization: `Bearer ${o}` }
+      });
+      if (a.ok && (await a.json()).state === "ready") return;
+      await new Promise((r) => setTimeout(r, 1e3));
+    }
+    throw new Error("Deploy did not become ready in time");
+  }
+}
+export {
+  n as AnonymousDropClient
+};

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

@@ -0,0 +1,6 @@
+import { DropClient } from './client';
+import { DeployProgress, DeployResult, ProcessedFile } from './types';
+export interface DeployOptions {
+    onProgress?: (e: DeployProgress) => void;
+}
+export declare function deployFiles(client: DropClient, files: ProcessedFile[], opts?: DeployOptions): Promise<DeployResult>;

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

@@ -0,0 +1,30 @@
+import { getDigest as w, getShas as y } from "./digest.js";
+const r = 5;
+async function d(e, h, u, t, i, a) {
+  const n = u.filter((p) => t.has(p.sha));
+  let l = 0, c = 0;
+  const o = async () => {
+    for (; l < n.length; ) {
+      const p = n[l++];
+      await e.uploadFile(h, p.path, p.content, i), a == null || a(++c);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(r, n.length) }, o));
+}
+async function f(e, h, u = {}) {
+  if (!h.length) throw new Error("No files to deploy");
+  const { onProgress: t } = u;
+  t == null || t({ phase: "creating" });
+  const i = await e.getToken(), a = await e.createDeploy(w(h), i), n = a.required.length;
+  return t == null || t({ phase: "uploading", uploaded: 0, total: n }), await d(
+    e,
+    a.id,
+    h,
+    y(a.required),
+    i,
+    (l) => t == null ? void 0 : t({ phase: "uploading", uploaded: l, total: n })
+  ), t == null || t({ phase: "processing" }), await e.waitUntilReady(a, i), t == null || t({ phase: "ready" }), { deploy: a, token: i, url: `https://${a.subdomain}.netlify.app` };
+}
+export {
+  f as deployFiles
+};

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

@@ -0,0 +1,3 @@
+import { Digest, ProcessedFile } from './types';
+export declare function getDigest(files: ProcessedFile[]): Digest;
+export declare function getShas(required: string[]): Set<string>;

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

@@ -0,0 +1,12 @@
+function o(t) {
+  const e = {};
+  for (const n of t) e[n.path] = n.sha;
+  return e;
+}
+function r(t) {
+  return new Set(t);
+}
+export {
+  o as getDigest,
+  r as getShas
+};

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

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

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

@@ -0,0 +1,16 @@
+import { getDigest as o, getShas as r } from "./digest.js";
+import { getSingleNonIndexHtmlFileName as l, hasMultipleHtmlFilesWithoutIndex as a, normalizeFiles as m, readDataTransfer as n, readFileList as s, readZip as p } from "./readFiles.js";
+import { AnonymousDropClient as x } from "./client.js";
+import { deployFiles as g } from "./deploy.js";
+export {
+  x as AnonymousDropClient,
+  g as deployFiles,
+  o as getDigest,
+  r as getShas,
+  l as getSingleNonIndexHtmlFileName,
+  a as hasMultipleHtmlFilesWithoutIndex,
+  m as normalizeFiles,
+  n as readDataTransfer,
+  s as readFileList,
+  p as readZip
+};

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

@@ -0,0 +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`.
+ */
+export declare function readDataTransfer(dt: DataTransfer): Promise<ProcessedFile[]>;
+export declare function readFileList(files: FileList): Promise<ProcessedFile[]>;
+export declare function readZip(zip: File): Promise<ProcessedFile[]>;
+export declare function normalizeFiles(files: ProcessedFile[]): ProcessedFile[];
+export declare function getSingleNonIndexHtmlFileName(files: ProcessedFile[]): string | null;
+export declare function hasMultipleHtmlFilesWithoutIndex(files: ProcessedFile[]): boolean;