@hiai-gg/docsmint 0.3.6 → 0.3.8

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

package/dist/frontend-ssr/assets/editorExtensions-DUzwndMy.js

@@ -0,0 +1,186 @@
+import { Node, mergeAttributes, textblockTypeInputRule } from "@tiptap/core";
+import CodeBlockLowlight from "@tiptap/extension-code-block-lowlight";
+import Highlight from "@tiptap/extension-highlight";
+import Image from "@tiptap/extension-image";
+import Link from "@tiptap/extension-link";
+import { TaskItem, TaskList } from "@tiptap/extension-list";
+import { TableKit } from "@tiptap/extension-table";
+import TextAlign from "@tiptap/extension-text-align";
+import { Markdown } from "@tiptap/markdown";
+import StarterKit from "@tiptap/starter-kit";
+import { common, createLowlight } from "lowlight";
+//#region src/lib/components/editor/editorExtensions.ts
+var lowlight = createLowlight(common);
+var EMPTY_PARAGRAPH_MARKDOWN = " ";
+var NBSP_CHAR = "\xA0";
+var TEXT_ALIGNMENTS = [
+	"left",
+	"center",
+	"right",
+	"justify"
+];
+var TextAlignParagraph = Node.create({
+	name: "paragraph",
+	priority: 1e3,
+	addOptions() {
+		return { HTMLAttributes: {} };
+	},
+	group: "block",
+	content: "inline*",
+	parseHTML() {
+		return [{ tag: "p" }];
+	},
+	renderHTML({ HTMLAttributes }) {
+		return [
+			"p",
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+			0
+		];
+	},
+	parseMarkdown: (token, helpers) => {
+		const tokens = token.tokens || [];
+		if (tokens.length === 1 && tokens[0].type === "image") return helpers.parseChildren([tokens[0]]);
+		const content = helpers.parseInline(tokens);
+		if (tokens.length === 1 && tokens[0].type === "text" && (tokens[0].raw === EMPTY_PARAGRAPH_MARKDOWN || tokens[0].text === EMPTY_PARAGRAPH_MARKDOWN || tokens[0].raw === NBSP_CHAR || tokens[0].text === NBSP_CHAR) && content.length === 1 && content[0].type === "text" && (content[0].text === EMPTY_PARAGRAPH_MARKDOWN || content[0].text === NBSP_CHAR)) return helpers.createNode("paragraph", void 0, []);
+		return helpers.createNode("paragraph", void 0, content);
+	},
+	renderMarkdown: (node, h, ctx) => {
+		if (!node) return "";
+		const content = Array.isArray(node.content) ? node.content : [];
+		const align = node.attrs?.textAlign ?? "";
+		const normalizedAlign = TEXT_ALIGNMENTS.includes(align) ? align : "";
+		if (normalizedAlign && normalizedAlign !== "left") return `<p style="text-align: ${normalizedAlign}">${content.length === 0 ? "" : h.renderChildren(content)}</p>`;
+		if (content.length === 0) {
+			const previousContent = Array.isArray(ctx?.previousNode?.content) ? ctx.previousNode.content : [];
+			return ctx?.previousNode?.type === "paragraph" && previousContent.length === 0 ? EMPTY_PARAGRAPH_MARKDOWN : "";
+		}
+		return h.renderChildren(content);
+	},
+	addCommands() {
+		return { setParagraph: () => ({ commands }) => {
+			return commands.setNode(this.name);
+		} };
+	},
+	addKeyboardShortcuts() {
+		return { "Mod-Alt-0": () => this.editor.commands.setParagraph() };
+	}
+});
+var HEADING_DEFAULT_LEVELS = [
+	1,
+	2,
+	3
+];
+var TextAlignHeading = Node.create({
+	name: "heading",
+	addOptions() {
+		return {
+			levels: [...HEADING_DEFAULT_LEVELS],
+			HTMLAttributes: {}
+		};
+	},
+	content: "inline*",
+	group: "block",
+	defining: true,
+	addAttributes() {
+		return { level: {
+			default: 1,
+			rendered: false
+		} };
+	},
+	parseHTML() {
+		return this.options.levels.map((level) => ({
+			tag: `h${level}`,
+			attrs: { level }
+		}));
+	},
+	renderHTML({ node, HTMLAttributes }) {
+		const levels = this.options.levels;
+		return [
+			`h${levels.includes(node.attrs.level) ? node.attrs.level : levels[0]}`,
+			mergeAttributes(this.options.HTMLAttributes, HTMLAttributes),
+			0
+		];
+	},
+	parseMarkdown: (token, helpers) => {
+		return helpers.createNode("heading", { level: token.depth || 1 }, helpers.parseInline(token.tokens || []));
+	},
+	renderMarkdown: (node, h) => {
+		const attrs = node.attrs ?? {};
+		const rawLevel = attrs.level;
+		const numericLevel = typeof rawLevel === "number" ? rawLevel : typeof rawLevel === "string" ? parseInt(rawLevel, 10) : 1;
+		const level = numericLevel >= 1 && numericLevel <= 6 ? Math.floor(numericLevel) : 1;
+		const headingChars = "#".repeat(level);
+		const content = Array.isArray(node.content) ? node.content : [];
+		const inner = h.renderChildren(content);
+		const align = attrs.textAlign ?? "";
+		const normalizedAlign = TEXT_ALIGNMENTS.includes(align) ? align : "";
+		if (normalizedAlign && normalizedAlign !== "left") return `<h${level} style="text-align: ${normalizedAlign}">${inner}</h${level}>`;
+		return `${headingChars} ${inner}`;
+	},
+	addCommands() {
+		return {
+			setHeading: (attributes) => ({ commands }) => {
+				if (!this.options.levels.includes(attributes.level)) return false;
+				return commands.setNode(this.name, attributes);
+			},
+			toggleHeading: (attributes) => ({ commands }) => {
+				if (!this.options.levels.includes(attributes.level)) return false;
+				return commands.toggleNode(this.name, "paragraph", attributes);
+			}
+		};
+	},
+	addKeyboardShortcuts() {
+		const shortcuts = {};
+		for (const level of this.options.levels) shortcuts[`Mod-Alt-${level}`] = () => this.editor.commands.toggleHeading({ level });
+		return shortcuts;
+	},
+	addInputRules() {
+		const levels = this.options.levels;
+		const min = Math.min(...levels);
+		return levels.map((level) => textblockTypeInputRule({
+			find: new RegExp(`^(#{${min},${level}})\\s$`),
+			type: this.type,
+			getAttributes: { level }
+		}));
+	}
+});
+var editorExtensions = [
+	StarterKit.configure({
+		heading: false,
+		paragraph: false,
+		codeBlock: false,
+		link: false
+	}),
+	Markdown.configure({}),
+	TextAlignParagraph,
+	TextAlignHeading,
+	Link.configure({
+		openOnClick: false,
+		HTMLAttributes: { class: "doc-link" }
+	}),
+	Image.configure({
+		inline: false,
+		allowBase64: false,
+		HTMLAttributes: { class: "doc-image" },
+		resize: {
+			enabled: true,
+			directions: [
+				"top-left",
+				"top-right",
+				"bottom-left",
+				"bottom-right"
+			],
+			minWidth: 96,
+			minHeight: 54,
+			alwaysPreserveAspectRatio: true
+		}
+	}),
+	Highlight.configure({ multicolor: true }),
+	CodeBlockLowlight.configure({ lowlight }),
+	TextAlign.configure({ types: ["heading", "paragraph"] }),
+	TableKit.configure({ table: { resizable: true } }),
+	TaskList,
+	TaskItem.configure({ nested: true })
+];
+//#endregion
+export { TextAlignParagraph as n, editorExtensions as r, TextAlignHeading as t };