repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/canvas/browser/drawing.ts
Rawimport { 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;
}