@hiai-gg/docsmint 0.3.7 → 0.3.9

package/dist/frontend-ssr/assets/document-drop-coordinator-CEaYACsC.js

@@ -0,0 +1,109 @@
+//#region src/lib/components/sidebar/document-drop-coordinator.ts
+function createDocumentPlacementWriter(options) {
+	const states = /* @__PURE__ */ new Map();
+	return function move(id, placement, initialConfirmed) {
+		let state = states.get(id);
+		if (!state) {
+			state = {
+				chain: Promise.resolve(),
+				confirmed: { ...initialConfirmed },
+				generation: 0
+			};
+			states.set(id, state);
+		}
+		const request = {
+			generation: ++state.generation,
+			placement: { ...placement },
+			token: options.optimistic(id, placement)
+		};
+		const run = state.chain.then(async () => {
+			try {
+				await options.patch(id, request.placement);
+				state.confirmed = { ...request.placement };
+				options.acknowledge(id, request.token);
+				if (options.refresh) options.refresh().catch(options.onRefreshError ?? (() => void 0));
+			} catch (error) {
+				options.acknowledge(id, request.token);
+				if (request.generation === state.generation) options.rollback(id, state.confirmed);
+				options.onError(error);
+				throw error;
+			}
+		});
+		state.chain = run.catch(() => void 0);
+		return run;
+	};
+}
+function createDocumentDropCoordinator(options) {
+	const defer = options.defer ?? ((callback) => setTimeout(callback, 0));
+	const cancel = options.cancel ?? clearTimeout;
+	const expire = options.expire ?? ((callback) => setTimeout(callback, 1e3));
+	const cancelExpire = options.cancelExpire ?? clearTimeout;
+	let active;
+	function clearActive() {
+		if (active?.pending) cancel(active.pending);
+		if (active?.expiry) cancelExpire(active.expiry);
+		active = void 0;
+	}
+	function lookup(id) {
+		return active?.id === id ? active : void 0;
+	}
+	return {
+		/**
+		* Returns the document whose drag transaction is still awaiting a
+		* destination. UI state may already have been cleared by the source
+		* zone's finalize event before a category-header drop is delivered.
+		*/
+		pendingId(token) {
+			return active && !active.resolved && active.token === token ? active.id : null;
+		},
+		begin(id, token) {
+			if (active?.id === id && active.token === token) return;
+			clearActive();
+			active = {
+				id,
+				token,
+				resolved: false,
+				pending: null,
+				expiry: null
+			};
+		},
+		end(id, token) {
+			const transaction = active;
+			if (!transaction || transaction.id !== id || transaction.token !== token || transaction.resolved || transaction.expiry) return;
+			transaction.expiry = expire(() => {
+				if (active === transaction && !transaction.resolved) clearActive();
+			});
+		},
+		cancel() {
+			clearActive();
+		},
+		zone(id, placement) {
+			const transaction = lookup(id);
+			if (!transaction || transaction.resolved) return;
+			if (transaction.pending) cancel(transaction.pending);
+			transaction.pending = defer(() => {
+				if (active === transaction && !transaction.resolved) {
+					transaction.pending = null;
+					if (transaction.expiry) {
+						cancelExpire(transaction.expiry);
+						transaction.expiry = null;
+					}
+					transaction.resolved = true;
+					options.persist(id, placement);
+				}
+			});
+		},
+		header(id, placement) {
+			const transaction = lookup(id);
+			if (!transaction || transaction.resolved) return;
+			if (transaction.pending) cancel(transaction.pending);
+			transaction.pending = null;
+			if (transaction.expiry) cancelExpire(transaction.expiry);
+			transaction.expiry = null;
+			transaction.resolved = true;
+			options.persist(id, placement);
+		}
+	};
+}
+//#endregion
+export { createDocumentPlacementWriter as n, createDocumentDropCoordinator as t };

package/dist/frontend-ssr/assets/documents-BnOTRdTY.js

@@ -0,0 +1,108 @@
+import { n as apiFetch } from "./client-DZMkDkDn.js";
+//#region src/lib/api/documents.ts
+var listDocumentsInflight = /* @__PURE__ */ new Map();
+var listDocumentsTtl = /* @__PURE__ */ new Map();
+var LIST_CACHE_TTL_MS = 5e3;
+function clearDocumentsCache() {
+	listDocumentsInflight.clear();
+	listDocumentsTtl.clear();
+}
+function listDocumentsCacheKey(params) {
+	if (!params) return "all";
+	return JSON.stringify({
+		folderId: params.folderId ?? null,
+		tag: params.tag ?? null,
+		page: params.page ?? 1,
+		limit: params.limit ?? null
+	});
+}
+function getTtlEntry(key) {
+	const entry = listDocumentsTtl.get(key);
+	if (!entry) return void 0;
+	if (Date.now() - entry.timestamp >= LIST_CACHE_TTL_MS) {
+		listDocumentsTtl.delete(key);
+		return;
+	}
+	return entry;
+}
+function setTtlEntry(key, promise) {
+	listDocumentsTtl.set(key, {
+		promise,
+		timestamp: Date.now()
+	});
+	setTimeout(() => {
+		listDocumentsTtl.delete(key);
+	}, LIST_CACHE_TTL_MS);
+}
+function listDocuments(params, fetcher) {
+	const key = listDocumentsCacheKey(params);
+	const inflight = listDocumentsInflight.get(key);
+	if (inflight) return inflight;
+	const ttl = getTtlEntry(key);
+	if (ttl) return ttl.promise;
+	const searchParams = new URLSearchParams();
+	if (params?.folderId) searchParams.set("folderId", params.folderId);
+	if (params?.tag) searchParams.set("tag", params.tag);
+	if (params?.page) searchParams.set("page", String(params.page));
+	if (params?.limit) searchParams.set("limit", String(params.limit));
+	const qs = searchParams.toString();
+	const promise = apiFetch(`/api/documents${qs ? `?${qs}` : ""}`, {}, fetcher).catch((err) => {
+		listDocumentsTtl.delete(key);
+		throw err;
+	});
+	listDocumentsInflight.set(key, promise);
+	setTtlEntry(key, promise);
+	promise.finally(() => {
+		listDocumentsInflight.delete(key);
+	});
+	return promise;
+}
+function getDocument(id, fetcher) {
+	return apiFetch(`/api/documents/${id}`, {}, fetcher);
+}
+function createDocument(data, fetcher) {
+	clearDocumentsCache();
+	return apiFetch("/api/documents", {
+		method: "POST",
+		body: JSON.stringify(data)
+	}, fetcher);
+}
+function updateDocument(id, data) {
+	clearDocumentsCache();
+	return apiFetch(`/api/documents/${id}`, {
+		method: "PATCH",
+		body: JSON.stringify(data)
+	});
+}
+function deleteDocument(id) {
+	clearDocumentsCache();
+	return apiFetch(`/api/documents/${id}`, { method: "DELETE" });
+}
+function importDocument(file, folderId) {
+	clearDocumentsCache();
+	const formData = new FormData();
+	formData.append("file", file);
+	if (folderId) formData.append("folderId", folderId);
+	return apiFetch("/api/documents/import", {
+		method: "POST",
+		body: formData
+	});
+}
+/**
+* Import one or more documents. Accepts any combination of supported
+* file types (markdown, text, JSON, DOCX). The backend endpoint accepts
+* a multipart body with multiple `file` parts and returns an
+* `ImportResponse` describing per-file success/failure.
+*/
+function importDocuments(files, folderId) {
+	clearDocumentsCache();
+	const formData = new FormData();
+	for (const file of files) formData.append("file", file);
+	if (folderId) formData.append("folderId", folderId);
+	return apiFetch("/api/documents/import", {
+		method: "POST",
+		body: formData
+	});
+}
+//#endregion
+export { importDocument as a, updateDocument as c, getDocument as i, createDocument as n, importDocuments as o, deleteDocument as r, listDocuments as s, clearDocumentsCache as t };