@surrealdb/ui 1.2.16 → 1.2.18

package/tests/unit/Stacker/helpers.test.ts

@@ -1,105 +0,0 @@
-import {
-	coveredEphemeral,
-	drawerDepthStyle,
-	resolveKind,
-	resolveLiveKind,
-	topOpened,
-} from "@src/lib/stacker";
-import type { StackerItem } from "@src/lib/stacker";
-import { describe, expect, it } from "vitest";
-
-describe("resolveKind", () => {
-	it("uses the explicit variant when provided", () => {
-		expect(resolveKind("drawer", false)).toBe("drawer");
-		expect(resolveKind("modal", true)).toBe("modal");
-	});
-
-	it("falls back to the viewport when no variant is set", () => {
-		expect(resolveKind(undefined, true)).toBe("drawer");
-		expect(resolveKind(undefined, false)).toBe("modal");
-	});
-});
-
-describe("resolveLiveKind", () => {
-	const drawerFirst: StackerItem[] = [
-		{ id: "a", opened: true, settings: { variant: "drawer" } },
-		{ id: "b", opened: true, settings: { variant: "modal" } },
-	];
-
-	it("returns null for an empty stack", () => {
-		expect(resolveLiveKind([], false)).toBeNull();
-	});
-
-	it("follows the first item's variant hint on desktop", () => {
-		expect(resolveLiveKind(drawerFirst, false)).toBe("drawer");
-	});
-
-	it("follows the viewport when the first item has no variant", () => {
-		const items: StackerItem[] = [{ id: "a", opened: true, settings: {} }];
-		expect(resolveLiveKind(items, true)).toBe("drawer");
-		expect(resolveLiveKind(items, false)).toBe("modal");
-	});
-
-	it("prefers a stack-level forced kind over the first item and viewport", () => {
-		const items: StackerItem[] = [{ id: "b", opened: true, settings: { variant: "modal" } }];
-		expect(resolveLiveKind(items, false, "drawer")).toBe("drawer");
-		expect(resolveLiveKind(items, true, "modal")).toBe("modal");
-	});
-});
-
-describe("topOpened", () => {
-	const items: StackerItem[] = [
-		{ id: "a", opened: true, settings: {} },
-		{ id: "b", opened: true, settings: {} },
-		{ id: "c", opened: false, settings: {} },
-	];
-
-	it("returns the top-most open item, skipping closing ones", () => {
-		expect(topOpened(items)?.id).toBe("b");
-		expect(topOpened([])).toBeUndefined();
-	});
-});
-
-describe("coveredEphemeral", () => {
-	it("returns open ephemeral items that would be covered by a new top", () => {
-		const items: StackerItem[] = [
-			{ id: "a", opened: true, settings: { ephemeral: true } },
-			{ id: "b", opened: true, settings: {} },
-			{ id: "c", opened: false, settings: { ephemeral: true } },
-		];
-		expect(coveredEphemeral(items, "new").map((i) => i.id)).toEqual(["a"]);
-	});
-
-	it("excludes the new top id even if that item is ephemeral", () => {
-		const items: StackerItem[] = [{ id: "a", opened: true, settings: { ephemeral: true } }];
-		expect(coveredEphemeral(items, "a")).toEqual([]);
-	});
-});
-
-describe("drawerDepthStyle", () => {
-	it("applies no transform at depth 0", () => {
-		expect(drawerDepthStyle("right", 0)).toEqual({
-			transform: "none",
-			transformOrigin: "center",
-		});
-	});
-
-	it("pushes outward from the free edge and scales down per side", () => {
-		expect(drawerDepthStyle("right", 1)).toEqual({
-			transform: "translateX(-12px) scale(0.96)",
-			transformOrigin: "0% 50%",
-		});
-		expect(drawerDepthStyle("left", 1)).toEqual({
-			transform: "translateX(12px) scale(0.96)",
-			transformOrigin: "100% 50%",
-		});
-		expect(drawerDepthStyle("bottom", 2)).toEqual({
-			transform: "translateY(-24px) scale(0.92)",
-			transformOrigin: "50% 0%",
-		});
-		expect(drawerDepthStyle("top", 2)).toEqual({
-			transform: "translateY(24px) scale(0.92)",
-			transformOrigin: "50% 100%",
-		});
-	});
-});

package/tests/unit/Stacker/reducer.test.ts

@@ -1,107 +0,0 @@
-import { STACKER_INITIAL_STATE, type StackerState, stackerReducer } from "@src/lib/stacker";
-import type { StackerItem } from "@src/lib/stacker";
-import { describe, expect, it } from "vitest";
-
-function item(id: string): StackerItem {
-	return { id, opened: true, settings: { title: id } };
-}
-
-function open(state: StackerState, id: string): StackerState {
-	return stackerReducer(state, { type: "OPEN", item: item(id) });
-}
-
-describe("stackerReducer", () => {
-	it("appends overlays in order", () => {
-		let state = open(STACKER_INITIAL_STATE, "a");
-		state = open(state, "b");
-		expect(state.items.map((i) => i.id)).toEqual(["a", "b"]);
-	});
-
-	it("no-ops when reopening an already-open id", () => {
-		const state = open(STACKER_INITIAL_STATE, "a");
-		expect(open(state, "a")).toBe(state);
-	});
-
-	it("revives a closing overlay in place and merges settings", () => {
-		let state = open(STACKER_INITIAL_STATE, "a");
-		state = stackerReducer(state, { type: "CLOSE", id: "a" });
-		expect(state.items[0].opened).toBe(false);
-
-		state = stackerReducer(state, {
-			type: "OPEN",
-			item: { id: "a", opened: true, settings: { title: "revived" } },
-		});
-		expect(state.items).toHaveLength(1);
-		expect(state.items[0].opened).toBe(true);
-		expect(state.items[0].settings.title).toBe("revived");
-	});
-
-	it("flips opened on CLOSE and is idempotent", () => {
-		const state = open(STACKER_INITIAL_STATE, "a");
-		const closed = stackerReducer(state, { type: "CLOSE", id: "a" });
-		expect(closed.items[0].opened).toBe(false);
-		expect(stackerReducer(closed, { type: "CLOSE", id: "a" })).toBe(closed);
-		expect(stackerReducer(state, { type: "CLOSE", id: "missing" })).toBe(state);
-	});
-
-	it("removes an item only on REMOVE", () => {
-		let state = open(STACKER_INITIAL_STATE, "a");
-		state = open(state, "b");
-
-		state = stackerReducer(state, { type: "REMOVE", id: "b" });
-		expect(state.items.map((i) => i.id)).toEqual(["a"]);
-
-		state = stackerReducer(state, { type: "REMOVE", id: "a" });
-		expect(state.items).toHaveLength(0);
-	});
-
-	it("locks a founding forced variant until the stack empties", () => {
-		let state = stackerReducer(STACKER_INITIAL_STATE, {
-			type: "OPEN",
-			item: {
-				id: "ephemeral",
-				opened: true,
-				settings: { variant: "drawer", ephemeral: true },
-			},
-		});
-		expect(state.forcedKind).toBe("drawer");
-
-		state = stackerReducer(state, {
-			type: "OPEN",
-			item: { id: "next", opened: true, settings: { variant: "modal" } },
-		});
-		expect(state.forcedKind).toBe("drawer");
-
-		state = stackerReducer(state, { type: "REMOVE", id: "ephemeral" });
-		expect(state.items.map((i) => i.id)).toEqual(["next"]);
-		expect(state.forcedKind).toBe("drawer");
-
-		state = stackerReducer(state, { type: "REMOVE", id: "next" });
-		expect(state.forcedKind).toBeNull();
-	});
-
-	it("does not lock kind when the founding overlay has no variant", () => {
-		const state = open(STACKER_INITIAL_STATE, "a");
-		expect(state.forcedKind).toBeNull();
-	});
-
-	it("closes every open item with CLOSE_ALL", () => {
-		let state = open(STACKER_INITIAL_STATE, "a");
-		state = open(state, "b");
-		const closed = stackerReducer(state, { type: "CLOSE_ALL" });
-		expect(closed.items.every((i) => !i.opened)).toBe(true);
-		expect(stackerReducer(closed, { type: "CLOSE_ALL" })).toBe(closed);
-	});
-
-	it("merges settings on UPDATE", () => {
-		const state = open(STACKER_INITIAL_STATE, "a");
-		const updated = stackerReducer(state, {
-			type: "UPDATE",
-			id: "a",
-			patch: { title: "renamed", withCloseButton: false },
-		});
-		expect(updated.items[0].settings.title).toBe("renamed");
-		expect(updated.items[0].settings.withCloseButton).toBe(false);
-		expect(stackerReducer(state, { type: "UPDATE", id: "missing", patch: {} })).toBe(state);
-	});
-});

package/tests/unit/Syntax/language.test.ts

@@ -1,63 +0,0 @@
-import { getLanguageName, getLanguageParser } from "@src/syntax/language";
-import { describe, expect, it } from "vitest";
-
-/**
- * Counts the error nodes a registered language produces for a source snippet.
- * A clean parse is the prerequisite for any highlighting at all, so this is
- * the cheapest signal that a grammar is configured for the syntax it claims
- * to support.
- */
-function errorCount(language: string, source: string): number {
-	const parser = getLanguageParser(language);
-
-	if (!parser) {
-		throw new Error(`No parser registered for "${language}"`);
-	}
-
-	let errors = 0;
-
-	parser.parse(source).iterate({
-		enter: (node) => {
-			if (node.type.isError) errors++;
-		},
-	});
-
-	return errors;
-}
-
-const TSX_SOURCE = `export function Greeting({ name }: { name: string }) {
-	return <View><Text>{name}</Text></View>;
-}`;
-
-const TS_SOURCE = `interface User { id: string; age?: number }
-const user: User = { id: "a" };`;
-
-const JS_SOURCE = `const ok = a < b && c > d;
-const shifted = (n) => n << 2 > 1;`;
-
-describe("language registry", () => {
-	it("registers tsx and jsx", () => {
-		expect(getLanguageParser("tsx")).toBeDefined();
-		expect(getLanguageParser("jsx")).toBeDefined();
-	});
-
-	it("resolves tsx and jsx to their base language names", () => {
-		expect(getLanguageName("tsx")).toBe("TypeScript");
-		expect(getLanguageName("jsx")).toBe("JavaScript");
-	});
-
-	it("parses JSX under jsx and tsx", () => {
-		expect(errorCount("jsx", "const a = <View><Text>hi</Text></View>;")).toBe(0);
-		expect(errorCount("tsx", TSX_SOURCE)).toBe(0);
-	});
-
-	it("parses TypeScript syntax under ts and tsx", () => {
-		expect(errorCount("ts", TS_SOURCE)).toBe(0);
-		expect(errorCount("tsx", TS_SOURCE)).toBe(0);
-	});
-
-	it("does not misread comparison operators as JSX in plain JavaScript", () => {
-		expect(errorCount("js", JS_SOURCE)).toBe(0);
-		expect(errorCount("ts", JS_SOURCE)).toBe(0);
-	});
-});

package/tools/duplicate-vector-mappings.json

@@ -1,143 +0,0 @@
-[
-	{
-		"uiKitFileName": "Memory",
-		"symbolId": "25796:1314",
-		"exportNodeId": "21128:24795",
-		"figmaVectorName": "Memory_vector",
-		"figmaFrameName": "Memory"
-	},
-	{
-		"uiKitFileName": "Compute",
-		"symbolId": "29295:58314",
-		"exportNodeId": "29295:58314",
-		"figmaVectorName": "Memory_vector",
-		"figmaFrameName": "Memory",
-		"figmaLightNodeId": "29295:58316"
-	},
-	{
-		"uiKitFileName": "HealthChat",
-		"symbolId": "25796:1395",
-		"exportNodeId": "21128:25857",
-		"figmaVectorName": "Chatbot_vector",
-		"figmaFrameName": "Chatbot"
-	},
-	{
-		"uiKitFileName": "Binary",
-		"symbolId": "25796:1513",
-		"exportNodeId": "25796:1513",
-		"figmaVectorName": "Code blob (JSON)_vector",
-		"figmaFrameName": "Code blob (JSON)",
-		"figmaLightNodeId": "25796:2418"
-	},
-	{
-		"uiKitFileName": "Clock",
-		"symbolId": "25796:1318",
-		"exportNodeId": "25796:1318",
-		"figmaVectorName": "Flexible_vector",
-		"figmaFrameName": "Flexible",
-		"figmaLightNodeId": "25796:2536"
-	},
-	{
-		"uiKitFileName": "CommitQueue",
-		"symbolId": "25796:1323",
-		"exportNodeId": "25796:1323",
-		"figmaVectorName": "Hands On_vector",
-		"figmaFrameName": "Hands On",
-		"figmaLightNodeId": "25796:2600"
-	},
-	{
-		"uiKitFileName": "Expand",
-		"symbolId": "25796:1502",
-		"exportNodeId": "25796:1502",
-		"figmaVectorName": "Scale_vector",
-		"figmaFrameName": "Scale",
-		"figmaLightNodeId": "25796:2001"
-	},
-	{
-		"uiKitFileName": "Swatch",
-		"symbolId": "25796:1413",
-		"exportNodeId": "25796:1413",
-		"figmaVectorName": "Palette_vector",
-		"figmaFrameName": "Palette",
-		"figmaLightNodeId": "25796:3530"
-	},
-	{
-		"uiKitFileName": "File",
-		"symbolId": "25796:1511",
-		"exportNodeId": "21128:25051",
-		"figmaVectorName": "Document_vector",
-		"figmaFrameName": "Document",
-		"figmaLightNodeId": "25796:2030"
-	},
-	{
-		"uiKitFileName": "Document",
-		"symbolId": "25796:1375",
-		"exportNodeId": "25796:1375",
-		"figmaVectorName": "Document_vector",
-		"figmaFrameName": "Document",
-		"figmaLightNodeId": "25796:2030"
-	},
-	{
-		"uiKitFileName": "Learn",
-		"symbolId": "25796:1493",
-		"exportNodeId": "21128:25729",
-		"figmaVectorName": "Learn_vector",
-		"figmaFrameName": "Learn",
-		"figmaLightNodeId": "25796:2836"
-	},
-	{
-		"uiKitFileName": "Tutorials",
-		"symbolId": "25796:1397",
-		"exportNodeId": "21128:25910",
-		"figmaVectorName": "Chat Heart_vector",
-		"figmaFrameName": "tutorials",
-		"figmaLightNodeId": "25796:2725"
-	},
-	{
-		"uiKitFileName": "MediaFile",
-		"symbolId": "25796:1452",
-		"exportNodeId": "25796:1452",
-		"figmaVectorName": "Video file_vector",
-		"figmaFrameName": "Video file",
-		"figmaLightNodeId": "25796:2498"
-	},
-	{
-		"uiKitFileName": "MergeQueue",
-		"symbolId": "25796:1356",
-		"exportNodeId": "25796:1356",
-		"figmaVectorName": "Flexible_vector",
-		"figmaFrameName": "Merge queue",
-		"figmaLightNodeId": "25796:3507"
-	},
-	{
-		"uiKitFileName": "Monitoring",
-		"symbolId": "25796:1527",
-		"exportNodeId": "25796:1527",
-		"figmaVectorName": "_vector",
-		"figmaFrameName": "Monitoring",
-		"figmaLightNodeId": "25796:3056"
-	},
-	{
-		"uiKitFileName": "Sun",
-		"symbolId": "25796:1363",
-		"exportNodeId": "25796:1363",
-		"figmaVectorName": "Union_vector",
-		"figmaFrameName": "Sun",
-		"figmaLightNodeId": "25796:3526"
-	},
-	{
-		"uiKitFileName": "Timeline",
-		"symbolId": "25796:1365",
-		"exportNodeId": "25796:1365",
-		"figmaVectorName": "Bars_vector",
-		"figmaFrameName": "Bars"
-	},
-	{
-		"uiKitFileName": "HealthBubble",
-		"symbolId": "25796:1366",
-		"exportNodeId": "21128:26006",
-		"figmaVectorName": "Health Chat_vector",
-		"figmaFrameName": "Health Bubble",
-		"figmaLightNodeId": "25796:3522"
-	}
-]

package/tools/glass-export-overrides.json

@@ -1,8 +0,0 @@
-[
-	{
-		"uiKitFileName": "Cursor",
-		"exportNodeId": "25755:47884",
-		"figmaFrameName": "Cursor",
-		"figmaLightName": "Cursor_light"
-	}
-]

package/tools/icon-parser.ts

@@ -1,78 +0,0 @@
-import { execSync } from "node:child_process";
-import { exists, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join, parse } from "node:path";
-
-import { JSDOM } from "jsdom";
-import { optimize } from "svgo";
-
-if (!Bun.which("picosvg")) {
-	console.error(
-		"🚨 picosvg is not installed. Please install it: https://github.com/googlefonts/picosvg",
-	);
-	process.exit(1);
-}
-
-if (!(await exists("icons.zip"))) {
-	console.error("🚨 icons.zip is not found. Please place it in the root of the project");
-	process.exit(2);
-}
-
-const iconsDir = await mkdtemp(join(tmpdir(), "icons-"));
-const interDir = await mkdtemp(join(tmpdir(), "inter-"));
-
-// Unzip the icons.zip file
-try {
-	execSync(`unzip icons.zip -d "${iconsDir}"`);
-} catch (error) {
-	console.error("Error unzipping icons.zip:", error.message);
-}
-
-// Read all SVG files in the icons directory
-const files = (await readdir(iconsDir)).filter((file) => file.endsWith(".svg")).sort();
-
-let bundleCode = "// Generated by SurrealDB UI Kit. Do not modify manually.\n\n";
-let pureCode = "// Generated by SurrealDB UI Kit. Do not modify manually.\n\n";
-
-for (const file of files) {
-	const inputPath = join(iconsDir, file);
-	const outputPath = join(interDir, file);
-	execSync(`picosvg "${inputPath}" --output_file "${outputPath}"`);
-
-	const { name } = parse(file);
-	const svg = await readFile(outputPath, "utf8");
-	const optimized = optimize(svg, {
-		multipass: true,
-		plugins: [
-			{
-				name: "mergePaths",
-				params: {
-					force: true,
-					noSpaceAfterFlags: false,
-				},
-			},
-		],
-	}).data;
-
-	const dom = new JSDOM(optimized);
-	const paths = dom.window.document.querySelectorAll("path");
-
-	if (paths.length !== 1) {
-		throw new Error(`Icon ${name} has ${paths.length} paths, expected 1`);
-	}
-
-	const iconPath = paths[0].getAttribute("d");
-
-	bundleCode += `export const icon${name}: string = "${iconPath}";\n`;
-	pureCode += `export { icon${name} as ${name} } from "./icons";\n`;
-
-	console.log(`🔄 Converted ${name}`);
-}
-
-await writeFile("./src/constants/icons.ts", bundleCode);
-await writeFile("./src/constants/icons-pure.ts", pureCode);
-
-console.log("✅ Updated icons.ts and icons-pure.ts!");
-
-await rm(iconsDir, { recursive: true });
-await rm(interDir, { recursive: true });

package/tools/integration-gradient-exports.json

@@ -1,57 +0,0 @@
-[
-	{ "uiKitFileName": "Sidekick", "exportNodeId": "22777:30583", "figmaFrameName": "Sidekick" },
-	{ "uiKitFileName": "Development", "exportNodeId": "25796:1453", "figmaFrameName": "Settings" },
-	{
-		"uiKitFileName": "CloudNodes",
-		"exportNodeId": "25796:1426",
-		"figmaFrameName": "cloud nodes"
-	},
-	{ "uiKitFileName": "Bot", "exportNodeId": "25796:1428", "figmaFrameName": "Agent / Bot" },
-	{ "uiKitFileName": "Agno", "exportNodeId": "21128:26168", "figmaFrameName": "Agno" },
-	{ "uiKitFileName": "Claude", "exportNodeId": "21128:26209", "figmaFrameName": "Claude" },
-	{ "uiKitFileName": "GitHub", "exportNodeId": "21128:26223", "figmaFrameName": "GitHub" },
-	{ "uiKitFileName": "Medium", "exportNodeId": "21128:26218", "figmaFrameName": "Medium" },
-	{ "uiKitFileName": "LangChain", "exportNodeId": "21128:26198", "figmaFrameName": "LangChain" },
-	{ "uiKitFileName": "Reddit", "exportNodeId": "21128:26190", "figmaFrameName": "Reddit" },
-	{ "uiKitFileName": "X", "exportNodeId": "21128:26194", "figmaFrameName": "X" },
-	{ "uiKitFileName": "MCP", "exportNodeId": "24452:1002", "figmaFrameName": "MCP" },
-	{ "uiKitFileName": "RAG", "exportNodeId": "21128:26228", "figmaFrameName": "RAG" },
-	{ "uiKitFileName": "Windsurf", "exportNodeId": "21128:26240", "figmaFrameName": "Windsurf" },
-	{ "uiKitFileName": "Instagram", "exportNodeId": "21128:26248", "figmaFrameName": "Instagram" },
-	{ "uiKitFileName": "Discord", "exportNodeId": "21128:26252", "figmaFrameName": "Discord" },
-	{ "uiKitFileName": "Zapier", "exportNodeId": "21128:26256", "figmaFrameName": "Zapier" },
-	{ "uiKitFileName": "Python", "exportNodeId": "21128:26096", "figmaFrameName": "Python" },
-	{ "uiKitFileName": "Cline", "exportNodeId": "21128:26114", "figmaFrameName": "Cline" },
-	{ "uiKitFileName": "Dev", "exportNodeId": "21128:26118", "figmaFrameName": "Dev" },
-	{ "uiKitFileName": "Rust", "exportNodeId": "21128:24875", "figmaFrameName": "Rust" },
-	{ "uiKitFileName": "Threads", "exportNodeId": "21128:26146", "figmaFrameName": "Threads" },
-	{ "uiKitFileName": "Zed", "exportNodeId": "21128:26150", "figmaFrameName": "Zed" },
-	{
-		"uiKitFileName": "StackOverflow",
-		"exportNodeId": "21128:26164",
-		"figmaFrameName": "Stack Overflow"
-	},
-	{ "uiKitFileName": "LinkedIn", "exportNodeId": "21128:26270", "figmaFrameName": "LinkedIn" },
-	{ "uiKitFileName": "Youtube", "exportNodeId": "21128:26274", "figmaFrameName": "YouTube" },
-	{ "uiKitFileName": "N8n", "exportNodeId": "21128:26131", "figmaFrameName": "n8n" },
-	{ "uiKitFileName": "Wasm", "exportNodeId": "21128:26139", "figmaFrameName": "WebAssembly" },
-	{
-		"uiKitFileName": "VisualStudioCode",
-		"exportNodeId": "21128:26178",
-		"figmaFrameName": "Visual Studio Code"
-	},
-	{ "uiKitFileName": "PDF", "exportNodeId": "25796:1324", "figmaFrameName": "Document / PDF" },
-	{
-		"uiKitFileName": "Javascript",
-		"exportNodeId": "23768:22323",
-		"figmaFrameName": "Javascript"
-	},
-	{ "uiKitFileName": "OpenAI", "exportNodeId": "24452:982", "figmaFrameName": "OpenAI" },
-	{
-		"uiKitFileName": "SurrealMCP",
-		"exportNodeId": "24452:1007",
-		"figmaFrameName": "MCP"
-	},
-	{ "uiKitFileName": "SurrealML", "exportNodeId": "25433:6610", "figmaFrameName": "SurrealML" },
-	{ "uiKitFileName": "YUApp", "exportNodeId": "21128:24571", "figmaFrameName": "YU app" }
-]

package/tools/picto-compare.ts

@@ -1,64 +0,0 @@
-/**
- * Compare Figma light exports against existing ui-kit pictos using perceptual hash.
- * Used to validate the picto-figma-map.json name mappings.
- *
- * Usage:
- *   bun tools/picto-compare.ts <urls-manifest.json>
- *
- * Manifest format: [{ fileName: "PadlockClosed", nodeId, url }] for light versions
- */
-
-import { execSync } from "node:child_process";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const PICTOS_DIR = join(import.meta.dir, "../src/assets/pictos");
-const TMP = join(import.meta.dir, "../.picto-compare");
-
-async function phash(path: string): Promise<string> {
-	return execSync(`magick "${path}" -colorspace Gray -resize 16x16! -depth 8 txt:-`, {
-		encoding: "utf8",
-	});
-}
-
-function hashDistance(a: string, b: string): number {
-	const valsA = [...a.matchAll(/\\((\\d+),(\\d+)\\)\\s+#(\\w+)/g)].map((m) =>
-		Number.parseInt(m[3], 16),
-	);
-	const valsB = [...b.matchAll(/\\((\\d+),(\\d+)\\)\\s+#(\\w+)/g)].map((m) =>
-		Number.parseInt(m[3], 16),
-	);
-	let dist = 0;
-	for (let i = 0; i < Math.min(valsA.length, valsB.length); i++) {
-		dist += Math.abs(valsA[i] - valsB[i]);
-	}
-	return dist;
-}
-
-async function main() {
-	const manifest: { fileName: string; url: string }[] = JSON.parse(
-		await readFile(process.argv[2], "utf8"),
-	);
-	await mkdir(TMP, { recursive: true });
-
-	const results: { fileName: string; distance: number; matched: boolean }[] = [];
-
-	for (const { fileName, url } of manifest) {
-		const figmaPng = join(TMP, `${fileName}-figma.png`);
-		const res = await fetch(url);
-		await writeFile(figmaPng, await res.arrayBuffer());
-
-		const repoWebp = join(PICTOS_DIR, `${fileName}.webp`);
-		const repoPng = join(TMP, `${fileName}-repo.png`);
-		execSync(`magick "${repoWebp}" "${repoPng}"`);
-
-		const dist = hashDistance(await phash(figmaPng), await phash(repoPng));
-		results.push({ fileName, distance: dist, matched: dist < 5000 });
-	}
-
-	const failed = results.filter((r) => !r.matched);
-	console.log(`Compared ${results.length}, mismatches: ${failed.length}`);
-	for (const f of failed) console.log(`  ${f.fileName}: distance ${f.distance}`);
-}
-
-main().catch(console.error);

package/tools/picto-merge-urls.ts

@@ -1,43 +0,0 @@
-/** Merge partial/agent screenshot URL results into urls.json */
-import { readdir, readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const PNG_DIR = join(import.meta.dir, "../.picto-gradient-png");
-
-const batchFiles = (await readdir(PNG_DIR))
-	.filter((f) => f.startsWith("screenshot-batch-") && f.endsWith(".json"))
-	.sort((a, b) => Number(a.match(/\d+/)?.[0]) - Number(b.match(/\d+/)?.[0]));
-
-const expected: { fileName: string; nodeId: string }[] = [];
-for (const f of batchFiles) {
-	expected.push(...JSON.parse(await readFile(join(PNG_DIR, f), "utf8")));
-}
-
-const resultFiles = [
-	"results-transparent-partial.json",
-	"results-partial.json",
-	...(await readdir(PNG_DIR))
-		.filter((f) => f.startsWith("results-agent-") && f.endsWith(".json"))
-		.sort(),
-];
-
-const byName = new Map<string, string>();
-for (const rf of resultFiles) {
-	try {
-		const entries: { fileName: string; url: string }[] = JSON.parse(
-			await readFile(join(PNG_DIR, rf), "utf8"),
-		);
-		for (const e of entries) byName.set(e.fileName, e.url);
-	} catch {
-		// file may not exist yet
-	}
-}
-
-const urls = expected.map(({ fileName }) => {
-	const url = byName.get(fileName);
-	if (!url) throw new Error(`Missing URL for ${fileName}`);
-	return { fileName, url };
-});
-
-await writeFile(join(PNG_DIR, "urls.json"), `${JSON.stringify(urls, null, 2)}\n`);
-console.log(`Merged ${urls.length} entries into urls.json`);