@qds.dev/tools 0.11.2 → 0.13.0

package/lib/rolldown/ui.qwik.mjs

@@ -0,0 +1,445 @@
+import { anyOf, createRegExp, exactly } from "magic-regexp";
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
+
+//#region rolldown/ui.ts
+const deriveContextField = (getterName) => getterName.slice(3, 4).toLowerCase() + getterName.slice(4);
+function generateComponentName(namespace, contextField, index) {
+	return `_Qds${namespace[0].toUpperCase() + namespace.slice(1)}${contextField[0].toUpperCase() + contextField.slice(1)}${index}`;
+}
+function collectUniqueNamespaces(target) {
+	const seen = /* @__PURE__ */ new Set();
+	const namespaces = [];
+	for (const ref of target.stateRefs) {
+		if (seen.has(ref.namespace.localName)) continue;
+		seen.add(ref.namespace.localName);
+		namespaces.push(ref.namespace);
+	}
+	for (const alias of target.aliasRefs) {
+		if (seen.has(alias.namespace.localName)) continue;
+		seen.add(alias.namespace.localName);
+		namespaces.push(alias.namespace);
+	}
+	return namespaces;
+}
+function getContextVarName(namespace, isSingle) {
+	return isSingle ? "ctx" : `${namespace.localName}Ctx`;
+}
+function isInsideDollarBoundary(ancestors) {
+	return ancestors.some((ancestor) => {
+		if (ancestor.type !== "CallExpression") return false;
+		const callee = ancestor.callee;
+		if (callee.type === "Identifier") return callee.name.endsWith("$") && callee.name !== "component$";
+		if (callee.type === "MemberExpression" && !callee.computed) return callee.property.name.endsWith("$");
+		return false;
+	});
+}
+function getFirstRef(target) {
+	if (target.stateRefs.length > 0) return {
+		namespace: target.stateRefs[0].namespace,
+		contextField: target.stateRefs[0].contextField
+	};
+	return {
+		namespace: target.aliasRefs[0].namespace,
+		contextField: target.aliasRefs[0].contextField
+	};
+}
+function rewriteExpression(source, expressionStart, expressionEnd, stateRefs, aliasRefs, isSingle) {
+	const replacements = [];
+	for (const ref of stateRefs) {
+		const ctxVar = isSingle ? "ctx" : `${ref.namespace.localName}Ctx`;
+		replacements.push({
+			start: ref.start - expressionStart,
+			end: ref.end - expressionStart,
+			text: `${ctxVar}.${ref.contextField}`
+		});
+	}
+	replacements.sort((a, b) => b.start - a.start);
+	let expr = source.slice(expressionStart, expressionEnd);
+	for (const r of replacements) expr = expr.slice(0, r.start) + r.text + expr.slice(r.end);
+	const seenAliases = /* @__PURE__ */ new Set();
+	for (const alias of aliasRefs) {
+		if (seenAliases.has(alias.localName)) continue;
+		seenAliases.add(alias.localName);
+		const replacement = `${isSingle ? "ctx" : `${alias.namespace.localName}Ctx`}.${alias.contextField}`;
+		expr = expr.replace(new RegExp(`\\b${alias.localName}\\b`, "g"), replacement);
+	}
+	return expr;
+}
+function buildUseContextLines(uniqueNamespaces) {
+	const isSingle = uniqueNamespaces.length === 1;
+	return uniqueNamespaces.map((ns) => {
+		return `  const ${getContextVarName(ns, isSingle)} = useContext(${ns.localName}.contextId);`;
+	}).join("\n");
+}
+function generateExpressionComponent(name, uniqueNamespaces, rewrittenExpression) {
+	return `\nconst ${name} = component$(() => {\n${buildUseContextLines(uniqueNamespaces)}\n  return (\n    <>\n      {${rewrittenExpression}}\n    </>\n  );\n});\n`;
+}
+function generateElementComponent(name, uniqueNamespaces, rewrittenElement) {
+	return `\nconst ${name} = component$(() => {\n${buildUseContextLines(uniqueNamespaces)}\n  return (\n    ${rewrittenElement}\n  );\n});\n`;
+}
+function generateHookComponent(name, uniqueNamespaces, rewrittenHook) {
+	return `const ${name} = component$(() => {\n${buildUseContextLines(uniqueNamespaces)}\n${rewrittenHook}\n  return <></>;\n});\n`;
+}
+function generateChainedHookComponent(name, uniqueNamespaces, rewrittenHook, consumingJsx) {
+	return `const ${name} = component$(() => {\n${buildUseContextLines(uniqueNamespaces)}\n${rewrittenHook}\n  return (\n    ${consumingJsx}\n  );\n});\n`;
+}
+const HOOK_NAMES = new Set([
+	"useTask$",
+	"useVisibleTask$",
+	"useComputed$"
+]);
+function filterToInnermostConsumers(ranges) {
+	const toRemove = /* @__PURE__ */ new Set();
+	for (let i = 0; i < ranges.length; i++) for (let j = 0; j < ranges.length; j++) {
+		if (i === j) continue;
+		if (ranges[i].start <= ranges[j].start && ranges[i].end >= ranges[j].end) toRemove.add(i);
+	}
+	for (let i = ranges.length - 1; i >= 0; i--) if (toRemove.has(i)) ranges.splice(i, 1);
+}
+function collectUniqueNamespacesFromRefs(stateRefs, aliasRefs) {
+	const seen = /* @__PURE__ */ new Set();
+	const namespaces = [];
+	for (const ref of stateRefs) {
+		if (seen.has(ref.namespace.localName)) continue;
+		seen.add(ref.namespace.localName);
+		namespaces.push(ref.namespace);
+	}
+	for (const alias of aliasRefs) {
+		if (seen.has(alias.namespace.localName)) continue;
+		seen.add(alias.namespace.localName);
+		namespaces.push(alias.namespace);
+	}
+	return namespaces;
+}
+function uiTransformCore(code, id, ast, s, importSources, debug, warn) {
+	const ancestors = [];
+	debug("processing", id);
+	const boundNamespaces = /* @__PURE__ */ new Map();
+	const stateRefs = /* @__PURE__ */ new Map();
+	const aliasBindings = /* @__PURE__ */ new Map();
+	const transformTargets = [];
+	const pendingWarnings = [];
+	const collectImportsAndBindings = function(node) {
+		if (node.type === "ImportDeclaration" && importSources.includes(node.source.value)) for (const specifier of node.specifiers) {
+			if (specifier.type !== "ImportSpecifier") continue;
+			const importedName = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+			const localName = specifier.local.name;
+			boundNamespaces.set(localName, {
+				localName,
+				importedName
+			});
+			debug("detected namespace", localName, "->", importedName);
+		}
+		if (node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && boundNamespaces.has(node.object.name) && node.property.name.startsWith("get")) {
+			const namespace = boundNamespaces.get(node.object.name);
+			const getterName = node.property.name;
+			stateRefs.set(String(node.start), {
+				node,
+				namespace,
+				getterName,
+				contextField: deriveContextField(getterName),
+				start: node.start,
+				end: node.end
+			});
+			debug("state ref", getterName, "->", deriveContextField(getterName));
+		}
+		if (node.type === "VariableDeclarator" && node.id.type === "Identifier" && node.init !== null && node.init.type === "MemberExpression" && !node.init.computed && node.init.object.type === "Identifier" && boundNamespaces.has(node.init.object.name) && node.init.property.name.startsWith("get")) {
+			const getterName = node.init.property.name;
+			aliasBindings.set(node.id.name, {
+				localName: node.id.name,
+				namespace: boundNamespaces.get(node.init.object.name),
+				getterName,
+				contextField: deriveContextField(getterName)
+			});
+			debug("alias binding (direct)", node.id.name, "->", getterName);
+		}
+		if (node.type === "VariableDeclarator" && node.id.type === "ObjectPattern" && node.init !== null && node.init.type === "Identifier" && boundNamespaces.has(node.init.name)) {
+			const namespace = boundNamespaces.get(node.init.name);
+			for (const prop of node.id.properties) {
+				if (prop.type !== "Property") continue;
+				if (prop.key.type !== "Identifier") continue;
+				const keyName = prop.key.name;
+				if (!keyName.startsWith("get")) continue;
+				if (prop.value.type === "ObjectPattern") throw new Error(`[vite-plugin-qds-ui] Nested destructuring of QDS state getter '${keyName}' from '${namespace.localName}' is not supported. Use simple destructuring: const { ${keyName} } = ${namespace.localName}`);
+				if (prop.value.type !== "Identifier") continue;
+				aliasBindings.set(prop.value.name, {
+					localName: prop.value.name,
+					namespace,
+					getterName: keyName,
+					contextField: deriveContextField(keyName)
+				});
+				debug("alias binding (destructure)", prop.value.name, "->", keyName, prop.shorthand ? "(shorthand)" : "(renamed)");
+			}
+		}
+	};
+	walk(ast, { enter: collectImportsAndBindings });
+	if (boundNamespaces.size === 0) return { changed: false };
+	if (stateRefs.size === 0 && aliasBindings.size === 0) return { changed: false };
+	const elementTargetRanges = [];
+	function collectRefsInRange(rangeStart, rangeEnd, rootNode) {
+		const foundStateRefs = [];
+		for (const ref of stateRefs.values()) if (ref.start >= rangeStart && ref.end <= rangeEnd) foundStateRefs.push(ref);
+		const foundAliasRefs = [];
+		walk(rootNode, { enter(innerNode) {
+			if (innerNode.type === "Identifier" && aliasBindings.has(innerNode.name)) foundAliasRefs.push(aliasBindings.get(innerNode.name));
+		} });
+		return {
+			stateRefs: foundStateRefs,
+			aliasRefs: foundAliasRefs
+		};
+	}
+	function hasGetterInAttributes(element) {
+		for (const attr of element.openingElement.attributes) {
+			if (attr.type !== "JSXAttribute") continue;
+			if (!attr.value) continue;
+			if (attr.value.type !== "JSXExpressionContainer") continue;
+			if (attr.value.expression.type === "JSXEmptyExpression") continue;
+			const { stateRefs: attrStateRefs, aliasRefs: attrAliasRefs } = collectRefsInRange(attr.value.start, attr.value.end, attr.value.expression);
+			if (attrStateRefs.length > 0 || attrAliasRefs.length > 0) return true;
+		}
+		return false;
+	}
+	walk(ast, {
+		enter(node) {
+			ancestors.push(node);
+			if (node.type === "JSXElement") {
+				const jsxElement = node;
+				if (elementTargetRanges.some((range) => range.start <= jsxElement.start && range.end >= jsxElement.end)) return;
+				if (isInsideDollarBoundary(ancestors)) return;
+				if (!hasGetterInAttributes(jsxElement)) return;
+				const { stateRefs: elementStateRefs, aliasRefs: elementAliasRefs } = collectRefsInRange(jsxElement.start, jsxElement.end, jsxElement);
+				if (elementStateRefs.length === 0 && elementAliasRefs.length === 0) return;
+				elementTargetRanges.push({
+					start: jsxElement.start,
+					end: jsxElement.end
+				});
+				transformTargets.push({
+					kind: "element",
+					stateRefs: elementStateRefs,
+					aliasRefs: elementAliasRefs,
+					start: jsxElement.start,
+					end: jsxElement.end
+				});
+			}
+			if (node.type === "JSXExpressionContainer") {
+				if (node.expression.type === "JSXEmptyExpression") return;
+				const containerStart = node.start;
+				const containerEnd = node.end;
+				if (isInsideDollarBoundary(ancestors)) {
+					const { stateRefs: containerStateRefs, aliasRefs: containerAliasRefs } = collectRefsInRange(containerStart, containerEnd, node.expression);
+					if (containerStateRefs.length > 0 || containerAliasRefs.length > 0) pendingWarnings.push("[vite-plugin-qds-ui] QDS state access found inside a $() boundary. The compiler cannot transform state access inside event handlers. Use the state through a JSX expression instead.");
+					return;
+				}
+				if (ancestors[ancestors.length - 2]?.type === "JSXAttribute") return;
+				if (transformTargets.some((target) => target.start <= containerStart && target.end >= containerEnd)) return;
+				const { stateRefs: containerStateRefs, aliasRefs: containerAliasRefs } = collectRefsInRange(containerStart, containerEnd, node.expression);
+				if (containerStateRefs.length === 0 && containerAliasRefs.length === 0) return;
+				transformTargets.push({
+					kind: "expression",
+					container: node,
+					stateRefs: containerStateRefs,
+					aliasRefs: containerAliasRefs,
+					start: containerStart,
+					end: containerEnd
+				});
+			}
+		},
+		leave() {
+			ancestors.pop();
+		}
+	});
+	for (const warning of pendingWarnings) warn?.(warning);
+	const collectedHookTargets = [];
+	walk(ast, { enter(node) {
+		if (node.type !== "CallExpression") return;
+		if (node.callee.type !== "Identifier" || node.callee.name !== "component$") return;
+		if (!node.arguments.length) return;
+		const fnArg = node.arguments[0];
+		const fnBody = fnArg.body;
+		if (!fnBody || fnBody.type !== "BlockStatement") return;
+		const bodyStmts = fnBody.body;
+		const rootPositions = /* @__PURE__ */ new Map();
+		walk(fnArg, { enter(inner) {
+			if (inner.type !== "JSXElement") return;
+			const opening = inner.openingElement;
+			if (opening.name.type !== "JSXMemberExpression") return;
+			const nsObj = opening.name.object;
+			const nsProp = opening.name.property;
+			if (nsObj.type === "JSXIdentifier" && nsProp.type === "JSXIdentifier" && nsProp.name === "root" && boundNamespaces.has(nsObj.name)) rootPositions.set(nsObj.name, opening.end);
+		} });
+		let returnPos = -1;
+		let returnNode = null;
+		for (const bStmt of bodyStmts) if (bStmt.type === "ReturnStatement") {
+			returnPos = bStmt.start;
+			returnNode = bStmt;
+			break;
+		}
+		const aliasDeclRanges = /* @__PURE__ */ new Map();
+		for (const bStmt of bodyStmts) {
+			if (bStmt.type !== "VariableDeclaration") continue;
+			for (const decl of bStmt.declarations) {
+				if (decl.id.type !== "ObjectPattern" || decl.init?.type !== "Identifier") continue;
+				if (!boundNamespaces.has(decl.init.name)) continue;
+				for (const prop of decl.id.properties) {
+					if (prop.type !== "Property" || prop.key.type !== "Identifier") continue;
+					if (!prop.key.name.startsWith("get")) continue;
+					const localName = prop.value.type === "Identifier" ? prop.value.name : prop.key.name;
+					aliasDeclRanges.set(localName, {
+						start: bStmt.start,
+						end: bStmt.end
+					});
+				}
+			}
+		}
+		for (const bStmt of bodyStmts) {
+			let expr;
+			let producedBinding = null;
+			if (bStmt.type === "ExpressionStatement") {
+				const exprStmt = bStmt.expression;
+				if (exprStmt.type !== "CallExpression") continue;
+				if (exprStmt.callee.type !== "Identifier" || !HOOK_NAMES.has(exprStmt.callee.name)) continue;
+				expr = exprStmt;
+			} else if (bStmt.type === "VariableDeclaration") {
+				const decls = bStmt.declarations;
+				if (decls.length !== 1) continue;
+				const decl = decls[0];
+				if (!decl.init || decl.init.type !== "CallExpression") continue;
+				if (decl.init.callee.type !== "Identifier" || !HOOK_NAMES.has(decl.init.callee.name)) continue;
+				if (decl.id.type !== "Identifier") continue;
+				expr = decl.init;
+				producedBinding = decl.id.name;
+			} else continue;
+			const callExpr = expr;
+			const hookStateRefs = [];
+			for (const ref of stateRefs.values()) if (ref.start >= callExpr.start && ref.end <= callExpr.end) hookStateRefs.push(ref);
+			const hookAliasRefs = [];
+			const seen = /* @__PURE__ */ new Set();
+			walk(bStmt, { enter(inner) {
+				if (inner.type !== "Identifier") return;
+				if (aliasBindings.has(inner.name) && !seen.has(inner.name)) {
+					seen.add(inner.name);
+					hookAliasRefs.push(aliasBindings.get(inner.name));
+				}
+			} });
+			if (hookStateRefs.length === 0 && hookAliasRefs.length === 0) continue;
+			const primary = hookStateRefs.length > 0 ? hookStateRefs[0] : {
+				namespace: hookAliasRefs[0].namespace,
+				contextField: hookAliasRefs[0].contextField
+			};
+			const rootEnd = rootPositions.get(primary.namespace.localName);
+			if (rootEnd === void 0) {
+				warn?.(`[vite-plugin-qds-ui] Getter used in ${expr.callee.name} but no <${primary.namespace.localName}.root> found in JSX return. Move this into a component rendered inside <${primary.namespace.localName}.root>.`);
+				continue;
+			}
+			let aliasDeclRange = null;
+			for (const alias of hookAliasRefs) {
+				const range = aliasDeclRanges.get(alias.localName);
+				if (range) {
+					aliasDeclRange = range;
+					break;
+				}
+			}
+			const jsxConsumers = [];
+			if (producedBinding !== null && returnNode !== null) {
+				walk(returnNode, { enter(inner) {
+					if (inner.type !== "JSXElement") return;
+					const jsxEl = inner;
+					let hasProducedRef = false;
+					walk(jsxEl, { enter(deepNode) {
+						if (deepNode.type !== "Identifier") return;
+						if (deepNode.name === producedBinding) hasProducedRef = true;
+					} });
+					if (hasProducedRef) jsxConsumers.push({
+						start: jsxEl.start,
+						end: jsxEl.end
+					});
+				} });
+				filterToInnermostConsumers(jsxConsumers);
+			}
+			collectedHookTargets.push({
+				statementStart: bStmt.start,
+				statementEnd: bStmt.end,
+				stateRefs: hookStateRefs,
+				aliasRefs: hookAliasRefs,
+				rootOpeningEnd: rootEnd,
+				returnStart: returnPos,
+				aliasDeclarationRange: aliasDeclRange,
+				producedBinding,
+				jsxConsumers
+			});
+		}
+	} });
+	if (transformTargets.length === 0 && collectedHookTargets.length === 0) return { changed: false };
+	const generated = transformTargets.map((target, index) => {
+		const uniqueNamespaces = collectUniqueNamespaces(target);
+		const firstRef = getFirstRef(target);
+		const name = generateComponentName(firstRef.namespace.localName, firstRef.contextField, index);
+		const isSingle = uniqueNamespaces.length === 1;
+		if (target.kind === "element") return {
+			name,
+			code: generateElementComponent(name, uniqueNamespaces, rewriteExpression(code, target.start, target.end, target.stateRefs, target.aliasRefs, isSingle))
+		};
+		return {
+			name,
+			code: generateExpressionComponent(name, uniqueNamespaces, rewriteExpression(code, target.container.expression.start, target.container.expression.end, target.stateRefs, target.aliasRefs, isSingle))
+		};
+	});
+	let lastImportEnd = 0;
+	for (const node of ast.body) if (node.type === "ImportDeclaration") lastImportEnd = Math.max(lastImportEnd, node.end);
+	debug("generated", generated.length, "components, insert at", lastImportEnd);
+	for (let i = 0; i < transformTargets.length; i++) s.overwrite(transformTargets[i].start, transformTargets[i].end, `<${generated[i].name} />`);
+	const coreNeeded = new Set(["component$", "useContext"]);
+	for (const node of ast.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (code.slice(node.source.start + 1, node.source.end - 1) !== "@qwik.dev/core") continue;
+		if (node.importKind === "type") continue;
+		for (const spec of node.specifiers) {
+			if (spec.type !== "ImportSpecifier") continue;
+			const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+			coreNeeded.delete(importedName);
+		}
+		if (coreNeeded.size === 0) continue;
+		const lastSpec = node.specifiers[node.specifiers.length - 1];
+		if (lastSpec) {
+			s.appendLeft(lastSpec.end, `, ${[...coreNeeded].join(", ")}`);
+			coreNeeded.clear();
+		}
+	}
+	if (coreNeeded.size > 0) s.appendLeft(lastImportEnd, `\nimport { ${[...coreNeeded].join(", ")} } from "@qwik.dev/core";`);
+	for (const g of generated) s.appendLeft(lastImportEnd, g.code);
+	const removedRanges = /* @__PURE__ */ new Set();
+	for (let hi = collectedHookTargets.length - 1; hi >= 0; hi--) {
+		const ht = collectedHookTargets[hi];
+		const uniqueNs = collectUniqueNamespacesFromRefs(ht.stateRefs, ht.aliasRefs);
+		const primary = ht.stateRefs.length > 0 ? ht.stateRefs[0] : {
+			namespace: ht.aliasRefs[0].namespace,
+			contextField: ht.aliasRefs[0].contextField
+		};
+		const compName = generateComponentName(primary.namespace.localName, primary.contextField, transformTargets.length + hi);
+		const isSingle = uniqueNs.length === 1;
+		const rewrittenHook = rewriteExpression(code, ht.statementStart, ht.statementEnd, ht.stateRefs, ht.aliasRefs, isSingle);
+		const isChained = ht.producedBinding !== null && ht.jsxConsumers.length > 0;
+		let hookComponentCode;
+		if (isChained) {
+			const consumers = ht.jsxConsumers;
+			hookComponentCode = generateChainedHookComponent(compName, uniqueNs, rewrittenHook, consumers.length === 1 ? code.slice(consumers[0].start, consumers[0].end) : `<>\n    ${consumers.map((c) => code.slice(c.start, c.end)).join("\n    ")}\n  </>`);
+		} else hookComponentCode = generateHookComponent(compName, uniqueNs, rewrittenHook);
+		s.remove(ht.statementStart, ht.statementEnd);
+		if (ht.aliasDeclarationRange) {
+			const key = `${ht.aliasDeclarationRange.start}-${ht.aliasDeclarationRange.end}`;
+			if (!removedRanges.has(key)) {
+				removedRanges.add(key);
+				s.remove(ht.aliasDeclarationRange.start, ht.aliasDeclarationRange.end);
+			}
+		}
+		if (isChained) for (const consumer of ht.jsxConsumers) s.remove(consumer.start, consumer.end);
+		s.appendLeft(ht.returnStart, hookComponentCode);
+		s.appendLeft(ht.rootOpeningEnd, `\n<${compName} />`);
+	}
+	return { changed: true };
+}
+
+//#endregion
+export { uiTransformCore };

package/lib/rolldown/ui.unit.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/icons/transform/mdx.d.ts

@@ -11,17 +11,9 @@ export declare function extractMDXAttributes(jsxNode: MDXJSXElement): {
     titleProp?: string;
     descriptionProp?: string;
 };
-/**
- * Transform MDX file using remark-mdx for semantic analysis
- * @param code - Original MDX source code
- * @param id - File ID
- * @param importSources - Sources to scan for imports
- * @param availableCollections - Set of available collection names
- * @param collectionNames - Map of alias to collection name
- * @param packs - Custom packs configuration
- * @param debug - Debug logging function
- * @returns Transformation result or null
- */
+export declare function transformMDXFileCore(code: string, id: string, s: MagicString, importSources: string[], availableCollections: Set<string>, collectionNames: Map<string, string>, packs: PacksMap | undefined, debug: (message: string, ...data: unknown[]) => void): {
+    changed: boolean;
+};
 export declare function transformMDXFile(code: string, id: string, importSources: string[], availableCollections: Set<string>, collectionNames: Map<string, string>, packs: PacksMap | undefined, debug: (message: string, ...data: unknown[]) => void): {
     code: string;
     map: ReturnType<MagicString["generateMap"]>;

package/lib/utils/icons/transform/mdx.qwik.mjs

@@ -40,27 +40,16 @@ import remarkMdx from "remark-mdx";
 		descriptionProp
 	};
 }
-/**
-* Transform MDX file using remark-mdx for semantic analysis
-* @param code - Original MDX source code
-* @param id - File ID
-* @param importSources - Sources to scan for imports
-* @param availableCollections - Set of available collection names
-* @param collectionNames - Map of alias to collection name
-* @param packs - Custom packs configuration
-* @param debug - Debug logging function
-* @returns Transformation result or null
-*/ function transformMDXFile(code, id, importSources, availableCollections, collectionNames, packs, debug) {
+function transformMDXFileCore(code, id, s, importSources, availableCollections, collectionNames, packs, debug) {
 	try {
 		debug(`[MDX] Parsing ${id}`);
 		const mdast = remark().use(remarkMdx).parse(code);
 		const aliasToPack = extractMDXImportAliases(mdast, importSources, availableCollections, collectionNames, packs, debug);
 		if (aliasToPack.size === 0) {
 			debug(`[MDX] No icon imports found in ${id}`);
-			return null;
+			return { changed: false };
 		}
 		debug("[MDX] Found icon imports:", Array.from(aliasToPack.entries()));
-		const s = new MagicString(code);
 		const ctx = {
 			usedImports: /* @__PURE__ */ new Set(),
 			importVars: /* @__PURE__ */ new Set(),
@@ -102,7 +91,7 @@ import remarkMdx from "remark-mdx";
 		} });
 		if (!hasChanges) {
 			debug(`[MDX] No icon elements found in ${id}`);
-			return null;
+			return { changed: false };
 		}
 		const importStatements = Array.from(ctx.usedImports).map((virtualId) => {
 			return `import ${ctx.virtualToVar.get(virtualId)} from '${virtualId}';`;
@@ -117,15 +106,20 @@ import remarkMdx from "remark-mdx";
 		}
 		s.appendLeft(insertPos, `${importStatements}\n`);
 		debug(`[MDX] Transformation complete for ${id}`);
-		return {
-			code: s.toString(),
-			map: s.generateMap({ hires: true })
-		};
+		return { changed: true };
 	} catch (error) {
 		debug("[MDX] Error transforming:", error);
-		return null;
+		return { changed: false };
 	}
 }
+function transformMDXFile(code, id, importSources, availableCollections, collectionNames, packs, debug) {
+	const s = new MagicString(code);
+	if (!transformMDXFileCore(code, id, s, importSources, availableCollections, collectionNames, packs, debug).changed) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: true })
+	};
+}
 
 //#endregion
-export { extractMDXAttributes, transformMDXFile };
+export { extractMDXAttributes, transformMDXFile, transformMDXFileCore };

package/lib/utils/icons/transform/tsx.d.ts

@@ -33,18 +33,9 @@ export declare function findIconElements(ast: Program, aliasToPack: Map<string,
  * @returns True if transformation was applied
  */
 export declare function transformIconElement(elem: JSXElement, s: MagicString, source: string, aliasToPack: Map<string, string>, collectionNames: Map<string, string>, packs: PacksMap | undefined, ctx: TransformContext, debug: (message: string, ...data: unknown[]) => void): boolean;
-/**
- * Transform TSX/JSX file
- * @param code - Original source code
- * @param id - File ID
- * @param ast - Parsed AST
- * @param aliasToPack - Map of aliases to pack names
- * @param collectionNames - Map of alias to collection name
- * @param availableCollections - Set of available collection names
- * @param packs - Custom packs configuration
- * @param debug - Debug logging function
- * @returns Transformation result or null
- */
+export declare function transformTSXFileCore(code: string, id: string, ast: Program, s: MagicString, aliasToPack: Map<string, string>, collectionNames: Map<string, string>, availableCollections: Set<string>, packs: PacksMap | undefined, debug: (message: string, ...data: unknown[]) => void): {
+    changed: boolean;
+};
 export declare function transformTSXFile(code: string, id: string, ast: Program, aliasToPack: Map<string, string>, collectionNames: Map<string, string>, availableCollections: Set<string>, packs: PacksMap | undefined, debug: (message: string, ...data: unknown[]) => void): {
     code: string;
     map: ReturnType<MagicString["generateMap"]>;

package/lib/utils/icons/transform/tsx.qwik.mjs

@@ -108,27 +108,15 @@ import { walk } from "oxc-walker";
 	debug(`[TRANSFORM_ICON] Successfully transformed ${alias}.${iconName} to SVG JSX`);
 	return true;
 }
-/**
-* Transform TSX/JSX file
-* @param code - Original source code
-* @param id - File ID
-* @param ast - Parsed AST
-* @param aliasToPack - Map of aliases to pack names
-* @param collectionNames - Map of alias to collection name
-* @param availableCollections - Set of available collection names
-* @param packs - Custom packs configuration
-* @param debug - Debug logging function
-* @returns Transformation result or null
-*/ function transformTSXFile(code, id, ast, aliasToPack, collectionNames, availableCollections, packs, debug) {
+function transformTSXFileCore(code, id, ast, s, aliasToPack, collectionNames, availableCollections, packs, debug) {
 	debug(`[TRANSFORM] Processing ${id} with ${aliasToPack.size} aliases:`, Array.from(aliasToPack.entries()));
 	debug(`[DEBUG] collectionNames map: ${JSON.stringify(Array.from(collectionNames.entries()))}`);
 	const iconElements = findIconElements(ast, aliasToPack, collectionNames, availableCollections);
 	if (iconElements.length === 0) {
 		debug(`[TRANSFORM] No icon elements found in ${id}`);
-		return null;
+		return { changed: false };
 	}
 	debug(`[TRANSFORM] Found ${iconElements.length} icon elements in ${id}`);
-	const s = new MagicString(code);
 	const ctx = {
 		usedImports: /* @__PURE__ */ new Set(),
 		importVars: /* @__PURE__ */ new Set(),
@@ -136,31 +124,34 @@ import { walk } from "oxc-walker";
 	};
 	let hasChanges = false;
 	for (let i = iconElements.length - 1; i >= 0; i--) if (transformIconElement(iconElements[i], s, code, aliasToPack, collectionNames, packs, ctx, debug)) hasChanges = true;
-	if (hasChanges) {
-		if (ctx.usedImports.size > 0) {
-			const virtualImports = `${Array.from(ctx.usedImports).map((virtualId) => {
-				return `import ${ctx.virtualToVar.get(virtualId)} from '${virtualId}';`;
-			}).join("\n")}\n`;
-			let insertPos = 0;
-			let importCount = 0;
-			for (const node of ast.body) if (node.type === "ImportDeclaration") {
-				insertPos = Math.max(insertPos, node.end);
-				importCount++;
-			}
-			debug(`Found ${importCount} imports, inserting at position ${insertPos}`);
-			s.appendLeft(insertPos, `\n${virtualImports.trimEnd()}\n`);
+	if (!hasChanges) {
+		debug(`[TRANSFORM] No changes made to ${id}`);
+		return { changed: false };
+	}
+	if (ctx.usedImports.size > 0) {
+		const virtualImports = `${Array.from(ctx.usedImports).map((virtualId) => {
+			return `import ${ctx.virtualToVar.get(virtualId)} from '${virtualId}';`;
+		}).join("\n")}\n`;
+		let insertPos = 0;
+		let importCount = 0;
+		for (const node of ast.body) if (node.type === "ImportDeclaration") {
+			insertPos = Math.max(insertPos, node.end);
+			importCount++;
 		}
-		const resultCode = s.toString();
-		debug(`Final transformed code length: ${resultCode.length}`);
-		debug(`[TRANSFORM] Transformation successful for ${id}, returning transformed code`);
-		return {
-			code: resultCode,
-			map: s.generateMap({ hires: true })
-		};
+		debug(`Found ${importCount} imports, inserting at position ${insertPos}`);
+		s.appendLeft(insertPos, `\n${virtualImports.trimEnd()}\n`);
 	}
-	debug(`[TRANSFORM] No changes made to ${id}`);
-	return null;
+	debug(`[TRANSFORM] Transformation successful for ${id}`);
+	return { changed: true };
+}
+function transformTSXFile(code, id, ast, aliasToPack, collectionNames, availableCollections, packs, debug) {
+	const s = new MagicString(code);
+	if (!transformTSXFileCore(code, id, ast, s, aliasToPack, collectionNames, availableCollections, packs, debug).changed) return null;
+	return {
+		code: s.toString(),
+		map: s.generateMap({ hires: true })
+	};
 }
 
 //#endregion
-export { findIconElements, isIconElement, transformIconElement, transformTSXFile };
+export { findIconElements, isIconElement, transformIconElement, transformTSXFile, transformTSXFileCore };