Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/canvas/browser/drawing.ts

Raw
import { convertToExcalidrawElements } from "@excalidraw/excalidraw";
import type { CanvasDraw, CanvasElement, CanvasState } from "../src/store.ts";

function isUnsafeMermaid(definition: string): boolean {
	return (
		!definition.trim() ||
		definition.length > 12_000 ||
		definition.split("\n").length > 400 ||
		/%%\{|^\s*---|\b(?:click|href|link|image)\b|<\/?[a-z]|https?:\/\//imu.test(
			definition,
		)
	);
}

function remapMermaid(
	elements: CanvasElement[],
	requestId: string,
	x: number,
	y: number,
): CanvasElement[] {
	if (!elements.length || elements.length > 300)
		throw new Error(
			"Mermaid conversion produced an unsupported number of elements.",
		);
	const left = Math.min(...elements.map((element) => Number(element.x) || 0));
	const top = Math.min(...elements.map((element) => Number(element.y) || 0));
	const ids = new Map(
		elements.map((element, index) => [
			element.id,
			`${requestId}-mermaid-${index}`,
		]),
	);
	const ref = (value: unknown): unknown =>
		typeof value === "string" ? (ids.get(value) ?? value) : value;
	return elements.map((source) => {
		const element = structuredClone(source) as CanvasElement;
		const id = ids.get(source.id);
		if (id === undefined)
			throw new Error("Mermaid conversion lost an element ID.");
		element.id = id;
		element.x = (Number(source.x) || 0) - left + x;
		element.y = (Number(source.y) || 0) - top + y;
		for (const key of ["containerId", "frameId"])
			element[key] = ref(element[key]);
		for (const key of ["startBinding", "endBinding"]) {
			const binding = element[key];
			if (binding && typeof binding === "object" && "elementId" in binding)
				element[key] = {
					...(binding as Record<string, unknown>),
					elementId: ref((binding as Record<string, unknown>)["elementId"]),
				};
		}
		if (Array.isArray(element["boundElements"]))
			element["boundElements"] = element["boundElements"].map((binding) =>
				binding && typeof binding === "object" && "id" in binding
					? {
							...(binding as Record<string, unknown>),
							id: ref((binding as Record<string, unknown>)["id"]),
						}
					: binding,
			);
		return element;
	});
}

export async function nativeAdditions(
	draw: CanvasDraw,
): Promise<CanvasElement[]> {
	if (draw.mermaid) {
		if (
			draw.additions.length ||
			draw.updates.length ||
			draw.moves.length ||
			draw.relabels.length ||
			draw.deleteIds.length
		)
			throw new Error(
				"Mermaid drawing cannot include normal drawing operations.",
			);
		if (isUnsafeMermaid(draw.mermaid.definition))
			throw new Error("Mermaid definition is unsafe or exceeds canvas limits.");
		const { parseMermaidToExcalidraw } = await import(
			"@excalidraw/mermaid-to-excalidraw"
		);
		const parsed = await parseMermaidToExcalidraw(draw.mermaid.definition, {
			maxEdges: 200,
			maxTextSize: 12_000,
		});
		if (
			parsed.files ||
			!parsed.elements.length ||
			parsed.elements.some(
				(element) =>
					(element as { type?: unknown }).type === "image" ||
					"fileId" in element,
			)
		)
			throw new Error(
				"Mermaid conversion produced an unsupported image or file.",
			);
		return remapMermaid(
			convertToExcalidrawElements(parsed.elements, {
				regenerateIds: false,
			}) as unknown as CanvasElement[],
			draw.id,
			draw.mermaid.x,
			draw.mermaid.y,
		);
	}
	const additions = convertToExcalidrawElements(
		draw.additions as Parameters<typeof convertToExcalidrawElements>[0],
		{ regenerateIds: false },
	) as unknown as CanvasElement[];
	if (additions.length > 300)
		throw new Error("Drawing contains too many native elements.");
	const sources = new Map(
		draw.additions.map((element) => [element.id, element]),
	);
	for (const addition of additions) {
		const source = sources.get(addition.id);
		if (
			addition.type === "arrow" &&
			!addition["startBinding"] &&
			!addition["endBinding"] &&
			!source?.["start"] &&
			!source?.["end"] &&
			Array.isArray(source?.["points"])
		)
			addition["points"] = structuredClone(source["points"]);
	}
	return additions;
}

export async function nativeRelabels(
	draw: CanvasDraw,
	state: CanvasState,
): Promise<Map<string, CanvasElement>> {
	const relabeled = new Map<string, CanvasElement>();
	for (const { id, text } of draw.relabels) {
		const source = state.elements.find((element) => element.id === id);
		if (!source) throw new Error("Relabel target disappeared.");
		if (source["autoResize"] === false)
			throw new Error("Relabel does not support fixed-width text.");
		const [measured] = convertToExcalidrawElements(
			[{ ...source, text, originalText: text }] as Parameters<
				typeof convertToExcalidrawElements
			>[0],
			{ regenerateIds: false },
		) as unknown as CanvasElement[];
		if (!measured || measured.id !== id)
			throw new Error("Text measurement changed its target.");
		relabeled.set(id, {
			...source,
			text,
			originalText: text,
			width: measured.width,
			height: measured.height,
			baseline: measured["baseline"] ?? source["baseline"],
		} as CanvasElement);
	}
	return relabeled;
}