@qds.dev/tools 0.11.1 → 0.11.2

package/{lib-types/tools → lib}/rolldown/as-child.d.ts

@@ -1,3 +1,4 @@
+import type { Plugin } from "rolldown";
 export type AsChildTypes = {
     asChild?: true;
 };
@@ -9,16 +10,6 @@ export type AsChildPluginOptions = {
  * @param options - Plugin configuration options
  * @returns Rolldown-compatible plugin object
  */
-export declare const asChild: (options?: AsChildPluginOptions) => {
-    name: string;
-    enforce: "pre";
-    transform: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<"/\\.(?:tsx|jsx)$/", never, [], never>;
-        };
-        handler(code: string, id: string): {
-            code: string;
-            map: import("magic-string").SourceMap;
-        } | null;
-    };
+export declare const asChild: (options?: AsChildPluginOptions) => Plugin & {
+    enforce?: "pre" | "post";
 };

package/lib/rolldown/icons.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from "rolldown";
+export type PacksMap = Record<string, {
+    iconifyPrefix: string;
+    sanitizeIcon?: (pascal: string) => string;
+}>;
+export type IconsPluginOptions = {
+    debug?: boolean;
+    /**
+     * The sources to scan for imports. By default this includes QDS, you can also add your own when creating library wrappers.
+     */
+    importSources?: string[];
+    packs?: PacksMap;
+};
+/**
+ * Rolldown plugin that transforms icon JSX elements to direct <svg /> calls
+ * @param options - Plugin configuration options
+ * @returns Rolldown-compatible plugin object
+ */
+export declare const icons: (options?: IconsPluginOptions) => Plugin & {
+    enforce?: "pre" | "post";
+};

package/lib/rolldown/icons.qwik.mjs

@@ -43,11 +43,6 @@ import { parseSync } from "oxc-parser";
 	return {
 		name: "vite-plugin-qds-icons",
 		enforce: "pre",
-		configResolved() {
-			debug("Icons plugin initialized with lazy loading");
-			collectionLoader.discoverCollections();
-			debug(`Plugin ready - ${collectionLoader.getAvailableCollections().size} collections available on-demand`);
-		},
 		transform: {
 			filter: { id: isTSXJSXOrMDX },
 			handler(code, id) {

package/{lib-types/tools → lib}/rolldown/index.d.ts

@@ -4,5 +4,6 @@ export type { IconsPluginOptions, PacksMap } from "./icons";
 export { icons } from "./icons";
 export type { InlineAssetPluginOptions } from "./inline-asset";
 export { inlineAsset } from "./inline-asset";
+export { injectComponentTypes } from "./inject-component-types";
 export { inlineCssPlugin } from "./inline-css";
 export { qwikRolldown } from "./qwik-rolldown";

package/lib/rolldown/index.qwik.mjs

@@ -1,7 +1,8 @@
 import { asChild } from "./as-child.qwik.mjs";
 import { icons } from "./icons.qwik.mjs";
 import { inlineAsset } from "./inline-asset.qwik.mjs";
+import { injectComponentTypes } from "./inject-component-types.qwik.mjs";
 import { inlineCssPlugin } from "./inline-css.qwik.mjs";
 import { qwikRolldown } from "./qwik-rolldown.qwik.mjs";
 
-export { asChild, icons, inlineAsset, inlineCssPlugin, qwikRolldown };
+export { asChild, icons, injectComponentTypes, inlineAsset, inlineCssPlugin, qwikRolldown };

package/lib/rolldown/inject-component-types.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export declare function injectComponentTypes(): Plugin;

package/lib/rolldown/inject-component-types.qwik.mjs

@@ -0,0 +1,138 @@
+import { getNodeText } from "../utils/ast/core.qwik.mjs";
+import { detectsRenderComponentUsage } from "../utils/ast/qwik.qwik.mjs";
+import { anyOf, createRegExp } from "magic-regexp";
+import MagicString from "magic-string";
+import { parseSync } from "oxc-parser";
+import { walk } from "oxc-walker";
+import { dirname, join, relative } from "node:path";
+
+//#region rolldown/inject-component-types.ts
+const tsFilePattern = createRegExp(anyOf(".tsx", ".ts"));
+const KNOWN_GENERIC_CALLS = {
+	createContextId: "ContextId",
+	createSignal: "Signal"
+};
+function injectComponentTypes() {
+	const asChildTypesModule = join(join(process.cwd(), "src"), "types");
+	return {
+		name: "rolldown-plugin-inject-component-types",
+		transform: {
+			order: "pre",
+			filter: { id: tsFilePattern },
+			handler(code, id) {
+				const parsed = parseSync(id, code);
+				if (parsed.errors.length > 0) return null;
+				const s = new MagicString(code);
+				const usesRender = detectsRenderComponentUsage(code);
+				let needsComponentImport = false;
+				let needsAsChildImport = false;
+				const additionalQwikImports = /* @__PURE__ */ new Set();
+				walk(parsed.program, { enter(node) {
+					if (node.type !== "ExportNamedDeclaration") return;
+					if (!("declaration" in node) || !node.declaration) return;
+					const declaration = node.declaration;
+					if (declaration.type !== "VariableDeclaration") return;
+					if (!("declarations" in declaration)) return;
+					for (const declarator of declaration.declarations) {
+						if (declarator.type !== "VariableDeclarator") continue;
+						if (!declarator.id || declarator.id.type !== "Identifier") continue;
+						if ("typeAnnotation" in declarator.id && declarator.id.typeAnnotation) continue;
+						if (!declarator.init || declarator.init.type !== "CallExpression") continue;
+						if (!("callee" in declarator.init)) continue;
+						const callee = declarator.init.callee;
+						if (!callee || callee.type !== "Identifier") continue;
+						const calleeName = getNodeText(callee, code);
+						if (calleeName === "component$") {
+							const propsType = extractComponentPropsType(declarator.init, code);
+							let annotation;
+							if (!propsType) annotation = ": Component";
+							else if (usesRender) {
+								annotation = `: Component<${propsType} & AsChildTypes>`;
+								needsAsChildImport = true;
+							} else annotation = `: Component<${propsType}>`;
+							s.appendLeft(declarator.id.end, annotation);
+							needsComponentImport = true;
+							continue;
+						}
+						const returnTypeName = KNOWN_GENERIC_CALLS[calleeName];
+						if (returnTypeName) {
+							const typeArg = extractCallTypeArgument(declarator.init, code);
+							if (typeArg) {
+								s.appendLeft(declarator.id.end, `: ${returnTypeName}<${typeArg}>`);
+								additionalQwikImports.add(returnTypeName);
+							}
+						}
+					}
+				} });
+				if (!s.hasChanged()) return null;
+				if (needsComponentImport) additionalQwikImports.add("Component");
+				if (additionalQwikImports.size > 0) addQwikImports(parsed, code, s, additionalQwikImports);
+				if (needsAsChildImport) {
+					let relPath = relative(dirname(id), asChildTypesModule);
+					if (!relPath.startsWith(".")) relPath = "./" + relPath;
+					s.prepend(`import type { AsChildTypes } from "${relPath}";\n`);
+				}
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			}
+		}
+	};
+}
+function extractCallTypeArgument(callExpr, code) {
+	if (!("typeArguments" in callExpr) || !callExpr.typeArguments) return null;
+	const ta = callExpr.typeArguments;
+	if (!ta.params?.length) return null;
+	return getNodeText(ta.params[0], code);
+}
+function extractComponentPropsType(callExpr, code) {
+	const typeArg = extractCallTypeArgument(callExpr, code);
+	if (typeArg) return typeArg;
+	if (!("arguments" in callExpr)) return null;
+	const args = callExpr.arguments;
+	if (args.length === 0) return null;
+	const callback = args[0];
+	if (callback.type !== "ArrowFunctionExpression" && callback.type !== "FunctionExpression") return null;
+	if ("typeParameters" in callback && callback.typeParameters) return null;
+	const params = callback.params;
+	if (!params || params.length === 0) return null;
+	const firstParam = params[0];
+	if (firstParam.type === "Identifier" && "typeAnnotation" in firstParam && firstParam.typeAnnotation) {
+		const ta = firstParam.typeAnnotation;
+		if (ta.typeAnnotation) return getNodeText(ta.typeAnnotation, code);
+	}
+	if (firstParam.type === "ObjectPattern" && "typeAnnotation" in firstParam) {
+		const annotation = firstParam.typeAnnotation;
+		if (annotation?.typeAnnotation) return getNodeText(annotation.typeAnnotation, code);
+	}
+	return null;
+}
+function addQwikImports(parsed, code, s, needed) {
+	for (const node of parsed.program.body) {
+		if (node.type !== "ImportDeclaration") continue;
+		if (!("source" in node)) continue;
+		if (code.slice(node.source.start + 1, node.source.end - 1) !== "@qwik.dev/core") continue;
+		if (!node.specifiers) continue;
+		for (const spec of node.specifiers) {
+			if (spec.type !== "ImportSpecifier") continue;
+			if (!("imported" in spec)) continue;
+			const imported = spec.imported;
+			if (imported?.name) needed.delete(imported.name);
+		}
+		if (needed.size === 0) return;
+		const lastSpec = node.specifiers[node.specifiers.length - 1];
+		if (lastSpec) {
+			const isTypeImport = "importKind" in node && node.importKind === "type";
+			const additions = Array.from(needed).map((n) => isTypeImport ? n : `type ${n}`).join(",\n  ");
+			s.appendLeft(lastSpec.end, `,\n  ${additions}`);
+			return;
+		}
+	}
+	if (needed.size === 0) return;
+	const names = Array.from(needed).join(", ");
+	s.prepend(`import type { ${names} } from "@qwik.dev/core";\n`);
+}
+
+//#endregion
+export { injectComponentTypes };

package/lib/rolldown/inline-css.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "rolldown";
+export declare function inlineCssPlugin(): Plugin;

package/lib/rolldown/qwik-rolldown.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "rolldown";
+/**
+ * Plugin to ensure .qwik.mjs extension and correct output dir
+ * Runs after qwikRollup to override its settings
+ */
+export declare function qwikRolldown(): Plugin;

package/lib/utils/index.qwik.mjs

@@ -7,8 +7,8 @@ import { buildSVGElement, generateIconImport } from "./icons/transform/shared.qw
 import { extractMDXAttributes, transformMDXFile } from "./icons/transform/mdx.qwik.mjs";
 import { findIconElements, isIconElement, transformIconElement, transformTSXFile } from "./icons/transform/tsx.qwik.mjs";
 import { getNodeText, isCallExpressionWithName, isIdentifierWithName } from "./ast/core.qwik.mjs";
-import { findImportBySource, getImportSource, hasImportSpecifier, injectTypeImport } from "./ast/imports.qwik.mjs";
 import { getJSXElementName, isJSXElementWithName } from "./ast/jsx-helpers.qwik.mjs";
+import { findImportBySource, getImportSource, hasImportSpecifier, injectTypeImport } from "./ast/imports.qwik.mjs";
 import { readPackageJson } from "./package-json.qwik.mjs";
 import { injectAsChildTypesImport, injectAsChildTypesIntoComponent, transformTypeFile } from "./transform-dts.qwik.mjs";
 

package/{lib-types/tools → lib}/utils/transform-dts.d.ts

@@ -4,12 +4,13 @@ import MagicString from "magic-string";
 import { parseSync } from "oxc-parser";
 declare function injectAsChildTypesIntoComponent(node: Node, content: string, s: MagicString): boolean;
 /**
- * Injects AsChildTypes import into the declaration file
+ * Injects AsChildTypes import using a relative path to the local as-child-types file
  */
 declare function injectAsChildTypesImport(options: {
     ast: ReturnType<typeof parseSync>;
     magicString: MagicString;
-    toolsImportNode: Node | null;
+    dtsPath: string;
+    declDir: string;
 }): void;
-declare function transformTypeFile(dtsPath: string, sourcePath: string): Promise<boolean>;
+declare function transformTypeFile(dtsPath: string, sourcePath: string, declDir: string): Promise<boolean>;
 export { injectAsChildTypesImport, injectAsChildTypesIntoComponent, transformTypeFile };

package/lib/utils/transform-dts.qwik.mjs

@@ -1,10 +1,10 @@
-import { findImportBySource, hasImportSpecifier, injectTypeImport } from "./ast/imports.qwik.mjs";
 import { detectsRenderComponentUsage } from "./ast/qwik.qwik.mjs";
+import { injectTypeImport } from "./ast/imports.qwik.mjs";
 import { walkFiles } from "./fs.qwik.mjs";
 import MagicString from "magic-string";
 import { parseSync } from "oxc-parser";
 import { walk } from "oxc-walker";
-import { join, relative } from "node:path";
+import { dirname, join, relative } from "node:path";
 import { readFile, stat, writeFile } from "node:fs/promises";
 
 //#region utils/transform-dts.ts
@@ -36,27 +36,21 @@ function injectAsChildTypesIntoComponent(node, content, s) {
 	return hasChanges;
 }
 /**
-* Injects AsChildTypes import into the declaration file
+* Injects AsChildTypes import using a relative path to the local as-child-types file
 */ function injectAsChildTypesImport(options) {
+	const asChildTypesTarget = join(options.declDir, "types");
+	let relImport = relative(dirname(options.dtsPath), asChildTypesTarget);
+	if (!relImport.startsWith(".")) relImport = "./" + relImport;
 	injectTypeImport({
 		ast: options.ast,
 		magicString: options.magicString,
-		importSource: "@qds.dev/tools",
-		specifierName: "AsChildTypes",
-		existingImportNode: options.toolsImportNode
+		importSource: relImport,
+		specifierName: "AsChildTypes"
 	});
 }
-async function transformTypeFile(dtsPath, sourcePath) {
+async function transformTypeFile(dtsPath, sourcePath, declDir) {
 	const content = await readFile(dtsPath, "utf-8");
-	const hasAsChildTypesUsage = content.includes("AsChildTypes");
-	if (hasAsChildTypesUsage) try {
-		const toolsImportNode = findImportBySource(parseSync(dtsPath, content), content, "@qds.dev/tools");
-		if (toolsImportNode) {
-			if (hasImportSpecifier(toolsImportNode, "AsChildTypes")) return false;
-		}
-	} catch {
-		return false;
-	}
+	if (content.includes("AsChildTypes")) return false;
 	try {
 		if (!detectsRenderComponentUsage(await readFile(sourcePath, "utf-8"))) return false;
 	} catch {
@@ -69,11 +63,12 @@ async function transformTypeFile(dtsPath, sourcePath) {
 		walk(ast.program, { enter(node) {
 			if (injectAsChildTypesIntoComponent(node, content, s)) hasChanges = true;
 		} });
-		if (!hasChanges && !hasAsChildTypesUsage) return false;
+		if (!hasChanges) return false;
 		injectAsChildTypesImport({
 			ast,
 			magicString: s,
-			toolsImportNode: findImportBySource(ast, content, "@qds.dev/tools")
+			dtsPath,
+			declDir
 		});
 		await writeFile(dtsPath, s.toString(), "utf-8");
 		return true;
@@ -84,8 +79,8 @@ async function transformTypeFile(dtsPath, sourcePath) {
 }
 async function main() {
 	const sourceDir = process.argv[2] || "./src";
-	const declDir = process.argv[3] || "./lib-types";
-	console.log(`🔍 Scanning ${sourceDir} for source files...`);
+	const declDir = process.argv[3] || "./lib/src";
+	console.log(`Scanning ${sourceDir} for source files...`);
 	let processedCount = 0;
 	let changedCount = 0;
 	for await (const sourcePath of walkFiles(sourceDir, ".tsx")) {
@@ -96,12 +91,12 @@ async function main() {
 			continue;
 		}
 		processedCount++;
-		if (await transformTypeFile(dtsPath, sourcePath)) {
+		if (await transformTypeFile(dtsPath, sourcePath, declDir)) {
 			changedCount++;
-			console.log(`✓ Transformed ${dtsPath}`);
+			console.log(`Transformed ${dtsPath}`);
 		}
 	}
-	console.log(`\n✨ Processed ${processedCount} files, transformed ${changedCount} files`);
+	console.log(`\nProcessed ${processedCount} files, transformed ${changedCount} files`);
 }
 if (import.meta.url === `file://${process.argv[1]}`) main().catch((error) => {
 	console.error("Error:", error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qds.dev/tools",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "private": false,
   "description": "Tools and utilities for Qwik Design System",
   "repository": {
@@ -8,40 +8,38 @@
     "url": "https://github.com/kunai-consulting/qwik-design-system"
   },
   "files": [
-    "lib",
-    "lib-types"
+    "lib"
   ],
   "type": "module",
   "sideEffects": false,
-  "main": "./lib/src/index.qwik.mjs",
-  "types": "./lib-types/tools/src/index.d.ts",
+  "main": "./lib/index.qwik.mjs",
+  "types": "./lib/src/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib-types/tools/src/index.d.ts",
-      "import": "./lib/src/index.qwik.mjs"
+      "types": "./lib/src/index.d.ts",
+      "import": "./lib/index.qwik.mjs"
     },
     "./package.json": "./package.json",
     "./vite": {
-      "types": "./lib-types/tools/vite/index.d.ts",
+      "types": "./lib/vite/index.d.ts",
       "import": "./lib/vite/index.qwik.mjs"
     },
     "./utils": {
-      "types": "./lib-types/tools/utils/index.d.ts",
+      "types": "./lib/utils/index.d.ts",
       "import": "./lib/utils/index.qwik.mjs"
     },
     "./rolldown": {
-      "types": "./lib-types/tools/rolldown/index.d.ts",
+      "types": "./lib/rolldown/index.d.ts",
       "import": "./lib/rolldown/index.qwik.mjs"
     },
     "./playground": {
-      "types": "./lib-types/tools/playground/index.d.ts",
+      "types": "./lib/playground/index.d.ts",
       "import": "./lib/playground/index.qwik.mjs"
     }
   },
   "scripts": {
-    "build": "pnpm run build.lib & pnpm run build.types && pnpm generate.icon.types",
-    "build.lib": "rolldown -c rolldown.config.ts",
-    "build.types": "tsc --emitDeclarationOnly --outDir ./lib-types",
+    "dev": "rolldown -c rolldown.config.ts -w",
+    "build": "rolldown -c rolldown.config.ts && tsc --emitDeclarationOnly --noEmit false && pnpm generate.icon.types",
     "generate.icon.types": "node src/generate/icon-types.ts"
   },
   "dependencies": {

package/lib-types/components/src/icons-runtime.d.ts

@@ -1,223 +0,0 @@
-import type * as GeneratedTypes from "../virtual-qds-icons";
-export declare const academicons: typeof GeneratedTypes.academicons;
-export declare const akaricons: typeof GeneratedTypes.akaricons;
-export declare const antdesign: typeof GeneratedTypes.antdesign;
-export declare const arcticons: typeof GeneratedTypes.arcticons;
-export declare const basil: typeof GeneratedTypes.basil;
-export declare const bi: typeof GeneratedTypes.bi;
-export declare const bitcoinicons: typeof GeneratedTypes.bitcoinicons;
-export declare const bpmn: typeof GeneratedTypes.bpmn;
-export declare const brandico: typeof GeneratedTypes.brandico;
-export declare const bubbles: typeof GeneratedTypes.bubbles;
-export declare const bx: typeof GeneratedTypes.bx;
-export declare const bxl: typeof GeneratedTypes.bxl;
-export declare const bxs: typeof GeneratedTypes.bxs;
-export declare const bytesize: typeof GeneratedTypes.bytesize;
-export declare const carbon: typeof GeneratedTypes.carbon;
-export declare const catppuccin: typeof GeneratedTypes.catppuccin;
-export declare const cbi: typeof GeneratedTypes.cbi;
-export declare const charm: typeof GeneratedTypes.charm;
-export declare const ci: typeof GeneratedTypes.ci;
-export declare const cib: typeof GeneratedTypes.cib;
-export declare const cif: typeof GeneratedTypes.cif;
-export declare const cil: typeof GeneratedTypes.cil;
-export declare const circleflags: typeof GeneratedTypes.circleflags;
-export declare const circum: typeof GeneratedTypes.circum;
-export declare const clarity: typeof GeneratedTypes.clarity;
-export declare const codex: typeof GeneratedTypes.codex;
-export declare const codicon: typeof GeneratedTypes.codicon;
-export declare const covid: typeof GeneratedTypes.covid;
-export declare const cryptocurrency: typeof GeneratedTypes.cryptocurrency;
-export declare const cryptocurrencycolor: typeof GeneratedTypes.cryptocurrencycolor;
-export declare const cuida: typeof GeneratedTypes.cuida;
-export declare const dashicons: typeof GeneratedTypes.dashicons;
-export declare const devicon: typeof GeneratedTypes.devicon;
-export declare const deviconline: typeof GeneratedTypes.deviconline;
-export declare const deviconoriginal: typeof GeneratedTypes.deviconoriginal;
-export declare const deviconplain: typeof GeneratedTypes.deviconplain;
-export declare const dinkieicons: typeof GeneratedTypes.dinkieicons;
-export declare const duoicons: typeof GeneratedTypes.duoicons;
-export declare const ei: typeof GeneratedTypes.ei;
-export declare const el: typeof GeneratedTypes.el;
-export declare const emojione: typeof GeneratedTypes.emojione;
-export declare const emojionemonotone: typeof GeneratedTypes.emojionemonotone;
-export declare const emojionev1: typeof GeneratedTypes.emojionev1;
-export declare const entypo: typeof GeneratedTypes.entypo;
-export declare const entyposocial: typeof GeneratedTypes.entyposocial;
-export declare const eosicons: typeof GeneratedTypes.eosicons;
-export declare const ep: typeof GeneratedTypes.ep;
-export declare const et: typeof GeneratedTypes.et;
-export declare const eva: typeof GeneratedTypes.eva;
-export declare const f7: typeof GeneratedTypes.f7;
-export declare const fa: typeof GeneratedTypes.fa;
-export declare const fa6brands: typeof GeneratedTypes.fa6brands;
-export declare const fa6regular: typeof GeneratedTypes.fa6regular;
-export declare const fa6solid: typeof GeneratedTypes.fa6solid;
-export declare const fa7brands: typeof GeneratedTypes.fa7brands;
-export declare const fa7regular: typeof GeneratedTypes.fa7regular;
-export declare const fa7solid: typeof GeneratedTypes.fa7solid;
-export declare const fabrands: typeof GeneratedTypes.fabrands;
-export declare const fad: typeof GeneratedTypes.fad;
-export declare const famicons: typeof GeneratedTypes.famicons;
-export declare const faregular: typeof GeneratedTypes.faregular;
-export declare const fasolid: typeof GeneratedTypes.fasolid;
-export declare const fe: typeof GeneratedTypes.fe;
-export declare const feather: typeof GeneratedTypes.feather;
-export declare const fileicons: typeof GeneratedTypes.fileicons;
-export declare const flag: typeof GeneratedTypes.flag;
-export declare const flagpack: typeof GeneratedTypes.flagpack;
-export declare const flatcoloricons: typeof GeneratedTypes.flatcoloricons;
-export declare const flatui: typeof GeneratedTypes.flatui;
-export declare const flowbite: typeof GeneratedTypes.flowbite;
-export declare const fluent: typeof GeneratedTypes.fluent;
-export declare const fluentcolor: typeof GeneratedTypes.fluentcolor;
-export declare const fluentemoji: typeof GeneratedTypes.fluentemoji;
-export declare const fluentemojiflat: typeof GeneratedTypes.fluentemojiflat;
-export declare const fluentemojihighcontrast: typeof GeneratedTypes.fluentemojihighcontrast;
-export declare const fluentmdl2: typeof GeneratedTypes.fluentmdl2;
-export declare const fontelico: typeof GeneratedTypes.fontelico;
-export declare const fontisto: typeof GeneratedTypes.fontisto;
-export declare const formkit: typeof GeneratedTypes.formkit;
-export declare const foundation: typeof GeneratedTypes.foundation;
-export declare const fxemoji: typeof GeneratedTypes.fxemoji;
-export declare const gala: typeof GeneratedTypes.gala;
-export declare const gameicons: typeof GeneratedTypes.gameicons;
-export declare const garden: typeof GeneratedTypes.garden;
-export declare const geo: typeof GeneratedTypes.geo;
-export declare const gg: typeof GeneratedTypes.gg;
-export declare const gis: typeof GeneratedTypes.gis;
-export declare const gravityui: typeof GeneratedTypes.gravityui;
-export declare const gridicons: typeof GeneratedTypes.gridicons;
-export declare const grommeticons: typeof GeneratedTypes.grommeticons;
-export declare const guidance: typeof GeneratedTypes.guidance;
-export declare const healthicons: typeof GeneratedTypes.healthicons;
-export declare const heroicons: typeof GeneratedTypes.heroicons;
-export declare const heroiconsoutline: typeof GeneratedTypes.heroiconsoutline;
-export declare const heroiconssolid: typeof GeneratedTypes.heroiconssolid;
-export declare const hugeicons: typeof GeneratedTypes.hugeicons;
-export declare const humbleicons: typeof GeneratedTypes.humbleicons;
-export declare const ic: typeof GeneratedTypes.ic;
-export declare const icomoonfree: typeof GeneratedTypes.icomoonfree;
-export declare const iconamoon: typeof GeneratedTypes.iconamoon;
-export declare const iconoir: typeof GeneratedTypes.iconoir;
-export declare const iconpark: typeof GeneratedTypes.iconpark;
-export declare const iconparkoutline: typeof GeneratedTypes.iconparkoutline;
-export declare const iconparksolid: typeof GeneratedTypes.iconparksolid;
-export declare const iconparktwotone: typeof GeneratedTypes.iconparktwotone;
-export declare const icons8: typeof GeneratedTypes.icons8;
-export declare const il: typeof GeneratedTypes.il;
-export declare const ion: typeof GeneratedTypes.ion;
-export declare const iwwa: typeof GeneratedTypes.iwwa;
-export declare const ix: typeof GeneratedTypes.ix;
-export declare const jam: typeof GeneratedTypes.jam;
-export declare const la: typeof GeneratedTypes.la;
-export declare const letsicons: typeof GeneratedTypes.letsicons;
-export declare const lineicons: typeof GeneratedTypes.lineicons;
-export declare const linemd: typeof GeneratedTypes.linemd;
-export declare const logos: typeof GeneratedTypes.logos;
-export declare const ls: typeof GeneratedTypes.ls;
-export declare const lsicon: typeof GeneratedTypes.lsicon;
-export declare const lucide: typeof GeneratedTypes.lucide;
-export declare const lucidelab: typeof GeneratedTypes.lucidelab;
-export declare const mage: typeof GeneratedTypes.mage;
-export declare const majesticons: typeof GeneratedTypes.majesticons;
-export declare const maki: typeof GeneratedTypes.maki;
-export declare const map: typeof GeneratedTypes.map;
-export declare const marketeq: typeof GeneratedTypes.marketeq;
-export declare const materialicontheme: typeof GeneratedTypes.materialicontheme;
-export declare const materialsymbols: typeof GeneratedTypes.materialsymbols;
-export declare const materialsymbolslight: typeof GeneratedTypes.materialsymbolslight;
-export declare const mdi: typeof GeneratedTypes.mdi;
-export declare const mdilight: typeof GeneratedTypes.mdilight;
-export declare const medicalicon: typeof GeneratedTypes.medicalicon;
-export declare const memory: typeof GeneratedTypes.memory;
-export declare const meteocons: typeof GeneratedTypes.meteocons;
-export declare const meteoricons: typeof GeneratedTypes.meteoricons;
-export declare const mi: typeof GeneratedTypes.mi;
-export declare const mingcute: typeof GeneratedTypes.mingcute;
-export declare const monoicons: typeof GeneratedTypes.monoicons;
-export declare const mynaui: typeof GeneratedTypes.mynaui;
-export declare const nimbus: typeof GeneratedTypes.nimbus;
-export declare const nonicons: typeof GeneratedTypes.nonicons;
-export declare const noto: typeof GeneratedTypes.noto;
-export declare const notov1: typeof GeneratedTypes.notov1;
-export declare const nrk: typeof GeneratedTypes.nrk;
-export declare const octicon: typeof GeneratedTypes.octicon;
-export declare const oi: typeof GeneratedTypes.oi;
-export declare const ooui: typeof GeneratedTypes.ooui;
-export declare const openmoji: typeof GeneratedTypes.openmoji;
-export declare const oui: typeof GeneratedTypes.oui;
-export declare const pajamas: typeof GeneratedTypes.pajamas;
-export declare const pepicons: typeof GeneratedTypes.pepicons;
-export declare const pepiconspencil: typeof GeneratedTypes.pepiconspencil;
-export declare const pepiconspop: typeof GeneratedTypes.pepiconspop;
-export declare const pepiconsprint: typeof GeneratedTypes.pepiconsprint;
-export declare const ph: typeof GeneratedTypes.ph;
-export declare const picon: typeof GeneratedTypes.picon;
-export declare const pixel: typeof GeneratedTypes.pixel;
-export declare const pixelarticons: typeof GeneratedTypes.pixelarticons;
-export declare const prime: typeof GeneratedTypes.prime;
-export declare const proicons: typeof GeneratedTypes.proicons;
-export declare const ps: typeof GeneratedTypes.ps;
-export declare const qlementineicons: typeof GeneratedTypes.qlementineicons;
-export declare const quill: typeof GeneratedTypes.quill;
-export declare const radixicons: typeof GeneratedTypes.radixicons;
-export declare const raphael: typeof GeneratedTypes.raphael;
-export declare const ri: typeof GeneratedTypes.ri;
-export declare const riveticons: typeof GeneratedTypes.riveticons;
-export declare const si: typeof GeneratedTypes.si;
-export declare const sidekickicons: typeof GeneratedTypes.sidekickicons;
-export declare const siglyph: typeof GeneratedTypes.siglyph;
-export declare const simpleicons: typeof GeneratedTypes.simpleicons;
-export declare const simplelineicons: typeof GeneratedTypes.simplelineicons;
-export declare const skillicons: typeof GeneratedTypes.skillicons;
-export declare const solar: typeof GeneratedTypes.solar;
-export declare const stash: typeof GeneratedTypes.stash;
-export declare const streamline: typeof GeneratedTypes.streamline;
-export declare const streamlineblock: typeof GeneratedTypes.streamlineblock;
-export declare const streamlinecolor: typeof GeneratedTypes.streamlinecolor;
-export declare const streamlinecyber: typeof GeneratedTypes.streamlinecyber;
-export declare const streamlinecybercolor: typeof GeneratedTypes.streamlinecybercolor;
-export declare const streamlineemojis: typeof GeneratedTypes.streamlineemojis;
-export declare const streamlineflex: typeof GeneratedTypes.streamlineflex;
-export declare const streamlineflexcolor: typeof GeneratedTypes.streamlineflexcolor;
-export declare const streamlinefreehand: typeof GeneratedTypes.streamlinefreehand;
-export declare const streamlinefreehandcolor: typeof GeneratedTypes.streamlinefreehandcolor;
-export declare const streamlineguidance: typeof GeneratedTypes.streamlineguidance;
-export declare const streamlinekameleoncolor: typeof GeneratedTypes.streamlinekameleoncolor;
-export declare const streamlinelogos: typeof GeneratedTypes.streamlinelogos;
-export declare const streamlinepixel: typeof GeneratedTypes.streamlinepixel;
-export declare const streamlineplump: typeof GeneratedTypes.streamlineplump;
-export declare const streamlineplumpcolor: typeof GeneratedTypes.streamlineplumpcolor;
-export declare const streamlinesharp: typeof GeneratedTypes.streamlinesharp;
-export declare const streamlinesharpcolor: typeof GeneratedTypes.streamlinesharpcolor;
-export declare const streamlinestickiescolor: typeof GeneratedTypes.streamlinestickiescolor;
-export declare const streamlineultimate: typeof GeneratedTypes.streamlineultimate;
-export declare const streamlineultimatecolor: typeof GeneratedTypes.streamlineultimatecolor;
-export declare const subway: typeof GeneratedTypes.subway;
-export declare const svgspinners: typeof GeneratedTypes.svgspinners;
-export declare const systemuicons: typeof GeneratedTypes.systemuicons;
-export declare const tabler: typeof GeneratedTypes.tabler;
-export declare const tdesign: typeof GeneratedTypes.tdesign;
-export declare const teenyicons: typeof GeneratedTypes.teenyicons;
-export declare const token: typeof GeneratedTypes.token;
-export declare const tokenbranded: typeof GeneratedTypes.tokenbranded;
-export declare const topcoat: typeof GeneratedTypes.topcoat;
-export declare const twemoji: typeof GeneratedTypes.twemoji;
-export declare const typcn: typeof GeneratedTypes.typcn;
-export declare const uil: typeof GeneratedTypes.uil;
-export declare const uim: typeof GeneratedTypes.uim;
-export declare const uis: typeof GeneratedTypes.uis;
-export declare const uit: typeof GeneratedTypes.uit;
-export declare const uiw: typeof GeneratedTypes.uiw;
-export declare const unjs: typeof GeneratedTypes.unjs;
-export declare const vaadin: typeof GeneratedTypes.vaadin;
-export declare const vs: typeof GeneratedTypes.vs;
-export declare const vscodeicons: typeof GeneratedTypes.vscodeicons;
-export declare const websymbol: typeof GeneratedTypes.websymbol;
-export declare const weui: typeof GeneratedTypes.weui;
-export declare const whh: typeof GeneratedTypes.whh;
-export declare const wi: typeof GeneratedTypes.wi;
-export declare const wpf: typeof GeneratedTypes.wpf;
-export declare const zmdi: typeof GeneratedTypes.zmdi;
-export declare const zondicons: typeof GeneratedTypes.zondicons;

package/lib-types/tools/rolldown/icons.d.ts

@@ -1,45 +0,0 @@
-export type PacksMap = Record<string, {
-    iconifyPrefix: string;
-    sanitizeIcon?: (pascal: string) => string;
-}>;
-export type IconsPluginOptions = {
-    debug?: boolean;
-    /**
-     * The sources to scan for imports. By default this includes QDS, you can also add your own when creating library wrappers.
-     */
-    importSources?: string[];
-    packs?: PacksMap;
-};
-/**
- * Rolldown plugin that transforms icon JSX elements to direct <svg /> calls
- * @param options - Plugin configuration options
- * @returns Rolldown-compatible plugin object
- */
-export declare const icons: (options?: IconsPluginOptions) => {
-    name: string;
-    enforce: "pre";
-    configResolved(): void;
-    transform: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<"/\\.(?:tsx|jsx|mdx)$/", never, [], never>;
-        };
-        handler(code: string, id: string): {
-            code: string;
-            map: import("magic-string").SourceMap;
-        } | null;
-    };
-    resolveId: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<"/^virtual:icons\\//", never, [], never>;
-        };
-        handler(source: string): string | null;
-    };
-    load: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<`/${string}virtual:icons\\//`, never, [], never>;
-        };
-        handler(id: string): Promise<{
-            code: string;
-        } | null>;
-    };
-};

package/lib-types/tools/rolldown/inline-css.d.ts

@@ -1,26 +0,0 @@
-/**
- * Rolldown plugin to handle CSS imports with ?inline query parameter
- * Mimics Vite's ?inline behavior by returning CSS content as a string
- */
-interface PluginContext {
-    error: (msg: string) => void;
-}
-export declare function inlineCssPlugin(): {
-    name: string;
-    resolveId: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<"/\\.css(?:$|\\?(?:[^\n])+)/", never, any[], never>;
-        };
-        handler(source: string, _importer?: string, _options?: unknown): null;
-    };
-    load: {
-        filter: {
-            id: import("magic-regexp").MagicRegExp<"/\\.css(?:$|\\?(?:[^\n])+)/", never, any[], never>;
-        };
-        handler(this: PluginContext, id: string): {
-            code: string;
-            map: null;
-        } | null;
-    };
-};
-export {};

package/lib-types/tools/rolldown/qwik-rolldown.d.ts

@@ -1,9 +0,0 @@
-import type { OutputOptions } from "rolldown";
-/**
- * Plugin to ensure .qwik.mjs extension and correct output dir
- * Runs after qwikRollup to override its settings
- */
-export declare function qwikRolldown(): {
-    name: string;
-    outputOptions(outputOpts: OutputOptions): OutputOptions;
-};