CanvasAnvil is an open source AI diagram maker and flowchart generator - an infinite-canvas diagram editor and self-hosted drawio alternative that writes editable .drawio files. Text to diagram, then fix nodes, layout and labels in place. Also AI presentations, interior design CAD/BOM, posters and infographics.
TypeScript ai-agentsai-diagramai-presentationbomcadcanvasdiagramdiagram-generatordrawioflowchartinfographicspptppt-generatorpresentation-generatorreactsvgedittext-to-diagramtypescriptworkflow
/**
* Browser-side normalisation for images handed to a model.
*
* Anything the user drops into a workspace can be a blob: URL, an oversized
* screenshot, or an already-inlined data URL. Models reject or choke on large
* payloads, so references are inlined, downscaled, and de-duplicated here
* before they reach the server proxy.
*/
const MAX_DIMENSION = 1536;
const MAX_DATA_URL_LENGTH = 1_800_000;
const JPEG_QUALITY = 0.86;
/** Pictures a vision request may carry alongside its prompt. */
export const MAX_REFERENCE_IMAGES = 3;
/**
* Pictures an image-generation request may carry.
*
* Higher than the vision cap because a slide's references are the deck's
* template plus whatever the user attached to that page, and the template
* alone used to leave room for two. Each one is downscaled first, so the
* ceiling here is roughly 10MB of request body.
*/
export const MAX_GENERATION_REFERENCE_IMAGES = 6;
export function cleanUrl(url: string) {
if (!url) return null;
if (url.startsWith('http')) return url;
// If it looks like a path but not absolute URL, return as is (might be base64 or relative)
if (url.startsWith('data:image')) return url;
return null;
}
async function objectUrlToDataUrl(objectUrl: string) {
if (typeof window === "undefined") return null;
if (!objectUrl || !objectUrl.startsWith("blob:")) return null;
try {
const resp = await fetch(objectUrl);
const blob = await resp.blob();
return await new Promise<string | null>((resolve) => {
const reader = new FileReader();
reader.onerror = () => resolve(null);
reader.onloadend = () => {
const result = reader.result;
resolve(typeof result === "string" ? result : null);
};
reader.readAsDataURL(blob);
});
} catch {
return null;
}
}
function getImageMimeFromDataUrl(dataUrl: string) {
const match = String(dataUrl || "").match(/^data:(image\/[a-zA-Z0-9.+-]+);base64,/i);
return match?.[1]?.toLowerCase() || "image/png";
}
async function compressDataImageUrlForModel(dataUrl: string) {
if (typeof window === "undefined" || typeof document === "undefined") return dataUrl;
if (!String(dataUrl || "").startsWith("data:image")) return dataUrl;
return await new Promise<string>((resolve) => {
const img = new Image();
img.onload = () => {
try {
const width = Number(img.naturalWidth || img.width || 0);
const height = Number(img.naturalHeight || img.height || 0);
if (!width || !height) {
resolve(dataUrl);
return;
}
const longestSide = Math.max(width, height);
const needsResize = longestSide > MAX_DIMENSION;
const needsReencode = dataUrl.length > MAX_DATA_URL_LENGTH;
if (!needsResize && !needsReencode) {
resolve(dataUrl);
return;
}
const scale = needsResize ? MAX_DIMENSION / longestSide : 1;
const targetWidth = Math.max(1, Math.round(width * scale));
const targetHeight = Math.max(1, Math.round(height * scale));
const canvas = document.createElement("canvas");
canvas.width = targetWidth;
canvas.height = targetHeight;
const ctx = canvas.getContext("2d");
if (!ctx) {
resolve(dataUrl);
return;
}
ctx.imageSmoothingEnabled = true;
ctx.imageSmoothingQuality = "high";
ctx.drawImage(img, 0, 0, targetWidth, targetHeight);
const originalMime = getImageMimeFromDataUrl(dataUrl);
const targetMime =
originalMime === "image/jpeg" || originalMime === "image/jpg" || needsReencode
? "image/jpeg"
: originalMime;
const compressed =
targetMime === "image/jpeg"
? canvas.toDataURL(targetMime, JPEG_QUALITY)
: canvas.toDataURL(targetMime);
resolve(compressed.length < dataUrl.length ? compressed : dataUrl);
} catch {
resolve(dataUrl);
}
};
img.onerror = () => resolve(dataUrl);
img.src = dataUrl;
});
}
export async function normalizeImageUrlForModel(url: string) {
const raw = String(url || "").trim();
if (!raw) return null;
if (raw.startsWith("blob:")) {
const dataUrl = await objectUrlToDataUrl(raw);
if (!dataUrl) return null;
return await compressDataImageUrlForModel(dataUrl);
}
if (raw.startsWith("data:image")) {
return await compressDataImageUrlForModel(raw);
}
return cleanUrl(raw);
}
export async function normalizeImageUrlsForModel(imageUrls: string[], maxImages: number) {
const normalized: string[] = [];
for (const raw of imageUrls) {
if (normalized.length >= maxImages) break;
const url = await normalizeImageUrlForModel(raw);
if (!url || normalized.includes(url)) continue;
normalized.push(url);
}
return normalized;
}