@cyberalien/svg-utils 0.0.1 → 0.0.3

package/lib/helpers/hash/css.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Convert hash to a string, usable in CSS for class names and keyframes
+ */
+declare function hashToCSSString(value: number[], limit?: number, hasPrefix?: boolean): string;
+export { hashToCSSString };

package/lib/helpers/hash/css.js

@@ -0,0 +1,27 @@
+const firstChars = "abcdefghijklmnopqrstuvwxyz";
+const chars = firstChars + "0123456789_-";
+const firstLetterRadix = 26;
+const letterRadix = 38;
+/**
+* Convert hash to a string, usable in CSS for class names and keyframes
+*/
+function hashToCSSString(value, limit = 8, hasPrefix = false) {
+	const result = [];
+	let num = value.shift() ?? 0;
+	if (!hasPrefix) {
+		result.push(firstChars[num % firstLetterRadix]);
+		num = Math.floor(num / firstLetterRadix);
+	}
+	while (true) {
+		while (num < 1) {
+			if (!value.length) return result.join("");
+			num = value.shift() ?? 0;
+		}
+		const isLastChar = result.length === limit - 1;
+		result.push(isLastChar ? firstChars[num % firstLetterRadix] : chars[num % letterRadix]);
+		if (result.length === limit) return result.join("");
+		num = Math.floor(num / letterRadix);
+	}
+}
+
+export { hashToCSSString };

package/lib/helpers/hash/hash.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simple hashing function, based on https://gist.github.com/jlevy/c246006675becc446360a798e2b2d781
+ */
+declare function hashString(str: string, seed?: number): [number, number];
+export { hashString };

package/lib/helpers/hash/hash.js

@@ -0,0 +1,18 @@
+/**
+* Simple hashing function, based on https://gist.github.com/jlevy/c246006675becc446360a798e2b2d781
+*/
+function hashString(str, seed = 0) {
+	let h1 = 3735928559 ^ seed, h2 = 1103547991 ^ seed;
+	for (let i = 0, ch; i < str.length; i++) {
+		ch = str.charCodeAt(i);
+		h1 = Math.imul(h1 ^ ch, 2654435761);
+		h2 = Math.imul(h2 ^ ch, 1597334677);
+	}
+	h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507);
+	h1 ^= Math.imul(h2 ^ h2 >>> 13, 3266489909);
+	h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507);
+	h2 ^= Math.imul(h1 ^ h1 >>> 13, 3266489909);
+	return [h2 >>> 0, h1 >>> 0];
+}
+
+export { hashString };

package/lib/helpers/hash/unique.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hash an object, make sure hash is unique
+ */
+declare function uniqueCSSHash(data: unknown, hasPrefix?: boolean): string;
+export { uniqueCSSHash };

package/lib/helpers/hash/unique.js

@@ -0,0 +1,23 @@
+import { sortObject } from "../misc/sort-object.js";
+import { hashString } from "./hash.js";
+import { hashToCSSString } from "./css.js";
+
+const uniqueHashes = Object.create(null);
+const uniqueWithPrefixHashes = Object.create(null);
+/**
+* Hash an object, make sure hash is unique
+*/
+function uniqueCSSHash(data, hasPrefix = false) {
+	const str = JSON.stringify(sortObject(data));
+	const hash = hashToCSSString(hashString(str), 6, hasPrefix);
+	const cache = hasPrefix ? uniqueWithPrefixHashes : uniqueHashes;
+	if (!cache[hash]) cache[hash] = str;
+	else if (cache[hash] !== str) {
+		console.warn("Data 1:", cache[hash]);
+		console.warn("Data 2:", str);
+		throw new Error(`Hash collision detected: ${hash}`);
+	}
+	return hash;
+}
+
+export { uniqueCSSHash };

package/lib/helpers/misc/clone.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Clone object, maintaining types
+ */
+declare function cloneObject<T>(item: T): T;
+export { cloneObject };

package/lib/helpers/misc/clone.js

@@ -0,0 +1,8 @@
+/**
+* Clone object, maintaining types
+*/
+function cloneObject(item) {
+	return JSON.parse(JSON.stringify(item));
+}
+
+export { cloneObject };

package/lib/helpers/misc/compare.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compare sets, returns true if identical
+ */
+declare function compareSets<T>(set1: Set<T> | undefined, set2: Set<T> | undefined): boolean;
+/**
+ * Compare two values, returns true if identical
+ */
+declare function compareValues<T>(value1: T, value2: T): boolean;
+export { compareSets, compareValues };

package/lib/helpers/misc/compare.js

@@ -0,0 +1,19 @@
+import { sortObject } from "./sort-object.js";
+
+/**
+* Compare sets, returns true if identical
+*/
+function compareSets(set1, set2) {
+	if (!set1 || !set2) return false;
+	if (set1.size !== set2.size) return false;
+	for (const value of set1) if (!set2.has(value)) return false;
+	return true;
+}
+/**
+* Compare two values, returns true if identical
+*/
+function compareValues(value1, value2) {
+	return value1 === value2 || JSON.stringify(sortObject(value1)) === JSON.stringify(sortObject(value2));
+}
+
+export { compareSets, compareValues };

package/lib/helpers/misc/sort-object.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Sort object keys to generate consistend JSON output
+ *
+ * Used to hash objects
+ */
+declare function sortObject<T>(data: T): T;
+export { sortObject };

package/lib/helpers/misc/sort-object.js

@@ -0,0 +1,21 @@
+/**
+* Sort object keys to generate consistend JSON output
+*
+* Used to hash objects
+*/
+function sortObject(data) {
+	if (typeof data !== "object" || data === null) return data;
+	if (Array.isArray(data)) return data.map(sortObject);
+	if (data instanceof Set) {
+		const values = Array.from(data).map(sortObject);
+		values.sort();
+		return new Set(values);
+	}
+	const keys = Object.keys(data);
+	keys.sort();
+	const newObject = Object.create(null);
+	for (const key of keys) newObject[key] = sortObject(data[key]);
+	return newObject;
+}
+
+export { sortObject };

package/lib/index.d.ts

@@ -1,5 +1,9 @@
+import { hashString } from "./helpers/hash/hash.js";
+import { cloneObject } from "./helpers/misc/clone.js";
+import { compareSets, compareValues } from "./helpers/misc/compare.js";
+import { sortObject } from "./helpers/misc/sort-object.js";
 import { ParsedXMLNode, ParsedXMLTagElement, ParsedXMLTextElement } from "./xml/types.js";
 import { iterateXMLContent } from "./xml/iterate.js";
 import { parseXMLContent } from "./xml/parse.js";
 import { stringifyXMLContent } from "./xml/stringify.js";
-export { ParsedXMLNode, ParsedXMLTagElement, ParsedXMLTextElement, iterateXMLContent, parseXMLContent, stringifyXMLContent };
+export { ParsedXMLNode, ParsedXMLTagElement, ParsedXMLTextElement, cloneObject, compareSets, compareValues, hashString, iterateXMLContent, parseXMLContent, sortObject, stringifyXMLContent };

package/lib/index.js

@@ -1,5 +1,9 @@
+import { cloneObject } from "./helpers/misc/clone.js";
+import { sortObject } from "./helpers/misc/sort-object.js";
+import { compareSets, compareValues } from "./helpers/misc/compare.js";
+import { hashString } from "./helpers/hash/hash.js";
 import { iterateXMLContent } from "./xml/iterate.js";
 import { parseXMLContent } from "./xml/parse.js";
 import { stringifyXMLContent } from "./xml/stringify.js";
 
-export { iterateXMLContent, parseXMLContent, stringifyXMLContent };
+export { cloneObject, compareSets, compareValues, hashString, iterateXMLContent, parseXMLContent, sortObject, stringifyXMLContent };

package/lib/svg/ids.d.ts

@@ -0,0 +1,7 @@
+import { ParsedXMLTagElement } from "../xml/types.js";
+type HashCallback = (id: string, content: string, tagName: string) => string;
+/**
+ * Change IDs in SVG using a callback function
+ */
+declare function changeSVGIDs(root: ParsedXMLTagElement[], callback: HashCallback): void;
+export { changeSVGIDs };

package/lib/svg/ids.js

@@ -0,0 +1,107 @@
+import { cloneObject } from "../helpers/misc/clone.js";
+import { iterateXMLContent } from "../xml/iterate.js";
+import { stringifyXMLContent } from "../xml/stringify.js";
+
+/**
+* Change IDs in SVG using a callback function
+*/
+function changeSVGIDs(root, callback) {
+	const idMap = /* @__PURE__ */ new Map();
+	const idNodes = /* @__PURE__ */ new Map();
+	const nestedIDs = /* @__PURE__ */ new Map();
+	const usage = [];
+	const parse = (replacement) => {
+		iterateXMLContent(root, (node, stack) => {
+			if (node.type !== "tag") return;
+			const attribs = node.attribs;
+			const nodeID = attribs.id;
+			if (typeof nodeID === "string") {
+				if (!replacement) {
+					if (idNodes.has(nodeID)) throw new Error(`Duplicate ID found: ${nodeID}`);
+					idNodes.set(nodeID, node);
+					idMap.set(node, nodeID);
+				} else if (nodeID === replacement[0]) attribs.id = replacement[1];
+			}
+			for (const attrib in attribs) {
+				const value = attribs[attrib];
+				if (typeof value !== "string") continue;
+				const add = (id) => {
+					usage.push({
+						node,
+						attrib,
+						id
+					});
+					[node, ...stack].forEach((node$1) => {
+						const parentID = idMap.get(node$1);
+						if (parentID) {
+							const nested = nestedIDs.get(parentID) || [];
+							if (!nested.includes(id)) {
+								nested.push(id);
+								nestedIDs.set(parentID, nested);
+							}
+						}
+					});
+				};
+				switch (attrib) {
+					case "id": break;
+					case "begin":
+					case "end": {
+						const newValue = value.split(";").map((part) => {
+							const chunks = part.trim().split(".");
+							if (chunks.length < 2) return part;
+							const time = chunks[1];
+							if (time?.startsWith("begin") || time?.startsWith("end")) {
+								const id = chunks.shift();
+								if (!replacement) add(id);
+								else if (id === replacement[0]) return `${replacement[1]}.${chunks.join(".")}`;
+							}
+							return part;
+						}).join(";");
+						if (replacement) attribs[attrib] = newValue;
+						break;
+					}
+					case "href":
+					case "xlink:href":
+						if (value.startsWith("#")) {
+							const id = value.slice(1);
+							if (!replacement) add(id);
+							else if (id === replacement[0]) attribs[attrib] = `#${replacement[1]}`;
+						}
+						break;
+					default: if (value.startsWith("url(#")) {
+						const id = value.slice(5, -1);
+						if (!replacement) add(id);
+						else if (id === replacement[0]) attribs[attrib] = `url(#${replacement[1]})`;
+					}
+				}
+			}
+		});
+	};
+	parse();
+	if (!idMap.size) return;
+	const allIDs = new Set(idMap.values());
+	const parseIDs = (parseAll = false) => {
+		const oldSize = allIDs.size;
+		for (const id of allIDs) {
+			const nested = nestedIDs.get(id)?.filter((nestedID) => nestedID !== id && allIDs.has(nestedID)) ?? [];
+			if (parseAll || !nested.length) {
+				const node = idNodes.get(id);
+				const newNode = cloneObject(node);
+				delete newNode.attribs.id;
+				for (const usageItem of usage) if (usageItem.node === node && usageItem.id === id) delete newNode.attribs[usageItem.attrib];
+				const content = stringifyXMLContent([newNode]);
+				if (!content) throw new Error(`Failed to stringify node with ID: ${id}`);
+				const newID = callback(id, content, node.tag);
+				if (newID !== id) parse([id, newID]);
+				allIDs.delete(id);
+			}
+		}
+		return allIDs.size !== oldSize;
+	};
+	while (allIDs.size) if (!parseIDs()) {
+		parseIDs(true);
+		return;
+	}
+}
+
+export { changeSVGIDs };

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "description": "Common functions for working with SVG used by various packages.",
   "author": "Vjacheslav Trushkin",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "license": "MIT",
   "bugs": "https://github.com/cyberalien/svg-utils/issues",
   "homepage": "https://cyberalien.dev/",