@qds.dev/tools 0.7.5 → 0.8.5

package/lib/repl/bundler/index.qwik.mjs

@@ -0,0 +1,89 @@
+import { getDeps } from "./bundled.qwik.mjs";
+
+//#region repl/bundler/index.ts
+var Bundler = class {
+	worker = null;
+	initP = null;
+	ready = null;
+	timer = null;
+	buildPromises = /* @__PURE__ */ new Map();
+	nextBuildId = 1;
+	constructor() {
+		this.initWorker();
+		this.keepAlive();
+	}
+	initWorker() {
+		this.initP = new Promise((res) => this.ready = res);
+		this.worker = new Worker(new URL("./repl-bundler-worker.ts", import.meta.url), { type: "module" });
+		this.worker.addEventListener("message", this.messageHandler);
+		this.worker.addEventListener("error", (e) => {
+			console.error(`Bundler worker failed`, e.message);
+			this.terminateWorker();
+		});
+	}
+	messageHandler = (e) => {
+		const { type } = e.data;
+		if (type === "ready") {
+			const message = {
+				type: "init",
+				deps: getDeps()
+			};
+			this.worker.postMessage.bind(this.worker)(message);
+			this.ready();
+		} else if (type === "result" || type === "error") {
+			const { buildId } = e.data;
+			const promise = this.buildPromises.get(buildId);
+			if (promise) {
+				this.buildPromises.delete(buildId);
+				if (type === "result") promise.resolve(e.data.result);
+				else {
+					const { error, stack } = e.data;
+					const err = new Error(error);
+					if (stack) err.stack = stack;
+					promise.reject(err);
+				}
+			}
+		}
+	};
+	keepAlive() {
+		clearTimeout(this.timer);
+		this.timer = setTimeout(() => this.terminateWorker(), 1e3 * 60 * 5);
+	}
+	bundle(options) {
+		if (!this.worker) this.initWorker();
+		this.keepAlive();
+		return this.initP.then(() => {
+			return new Promise((resolve, reject) => {
+				const buildId = this.nextBuildId++;
+				this.buildPromises.set(buildId, {
+					resolve,
+					reject
+				});
+				const message = {
+					type: "bundle",
+					buildId,
+					data: options
+				};
+				const postMessage = this.worker?.postMessage.bind(this.worker);
+				postMessage?.(message);
+			});
+		});
+	}
+	terminateWorker() {
+		if (this.worker) {
+			this.worker.removeEventListener("message", this.messageHandler);
+			this.worker.terminate();
+			this.worker = null;
+			this.buildPromises.forEach((p) => p.reject(/* @__PURE__ */ new Error("Worker terminated")));
+			this.buildPromises.clear();
+		}
+	}
+};
+let bundler;
+const getBundler = () => {
+	if (!bundler) bundler = new Bundler();
+	return bundler;
+};
+
+//#endregion
+export { getBundler };

package/lib/repl/index.qwik.mjs

@@ -0,0 +1,21 @@
+import { getBundler } from "./bundler/index.qwik.mjs";
+
+//#region repl/index.ts
+var ReplCompiler = class {
+	options;
+	bundler;
+	constructor(options) {
+		this.options = options;
+		this.bundler = getBundler();
+	}
+	async compile(input) {
+		const finalOptions = {
+			...this.options,
+			...input
+		};
+		return this.bundler.bundle(finalOptions);
+	}
+};
+
+//#endregion
+export { ReplCompiler };

package/lib/repl/repl-constants.qwik.mjs

@@ -0,0 +1,5 @@
+//#region repl/repl-constants.ts
+const QWIK_PKG_NAME = "@qwik.dev/core";
+
+//#endregion
+export { QWIK_PKG_NAME };

package/lib/rolldown/index.qwik.mjs

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

package/lib/rolldown/inline-asset.qwik.mjs

@@ -0,0 +1,171 @@
+import { anyOf, char, createRegExp, exactly, maybe, oneOrMore } from "magic-regexp";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+
+//#region rolldown/inline-asset.ts
+const nodeRequire = createRequire(import.meta.url);
+/**
+* Embeds file content as build-time assets, returning URLs to the inlined content.
+* Supports both relative paths and package imports (e.g., @qwik.dev/core/dist/...).
+*
+* Supports two query parameters:
+* - `?inline-asset` - Inlines the file content as an asset
+* - `?no-transform` - Returns raw file content without any transformations
+*
+* @param options - Plugin configuration options
+* @returns Rolldown/Vite-compatible plugin object
+*/ const inlineAsset = (options = {}) => {
+	const { debug: isDebugMode = false, outDir = "public/.qds-inline-assets" } = options;
+	const debugInlineAsset = (...args) => {
+		if (!isDebugMode) return;
+		console.log("[inline-asset]", ...args);
+	};
+	let isDevMode = false;
+	const assetDir = join(process.cwd(), outDir);
+	if (!existsSync(assetDir)) {
+		mkdirSync(assetDir, { recursive: true });
+		debugInlineAsset("Created asset directory:", assetDir);
+	}
+	const inlineAssetQuery = createRegExp(anyOf("?", "&"), exactly("inline-asset"));
+	const noTransformQuery = createRegExp(anyOf("?", "&"), exactly("no-transform"));
+	const combinedQuery = createRegExp(anyOf("?", "&"), anyOf(exactly("inline-asset"), exactly("no-transform")));
+	const inlineAssetPattern = createRegExp(anyOf(exactly("?"), exactly("&")), exactly("inline-asset"), maybe(exactly("&"), oneOrMore(char)), ["g"]);
+	const noTransformPattern = createRegExp(anyOf(exactly("?"), exactly("&")), exactly("no-transform"), maybe(exactly("&"), oneOrMore(char)), ["g"]);
+	return {
+		name: "inline-asset",
+		configResolved(config) {
+			isDevMode = config.command === "serve";
+			debugInlineAsset("Dev mode:", isDevMode);
+		},
+		resolveId: {
+			order: "pre",
+			filter: { id: combinedQuery },
+			async handler(id, importer, options$1) {
+				const isInlineAsset = inlineAssetQuery.test(id);
+				const isNoTransform = noTransformQuery.test(id);
+				if (!isInlineAsset && !isNoTransform) return;
+				debugInlineAsset("resolveId:", {
+					id,
+					importer,
+					isInlineAsset,
+					isNoTransform
+				});
+				const basePath = id.replace(inlineAssetPattern, "").replace(noTransformPattern, "");
+				debugInlineAsset("Resolving base path:", basePath);
+				let resolvedPath = null;
+				try {
+					const resolved = await this.resolve(basePath, importer, {
+						...options$1,
+						skipSelf: true
+					});
+					if (resolved) resolvedPath = resolved.id.split("?")[0];
+				} catch {
+					if (basePath.startsWith("@") || !basePath.startsWith(".") && !basePath.startsWith("/")) {
+						const parts = basePath.split("/");
+						let packageName;
+						let subpathStartIndex;
+						if (basePath.startsWith("@")) {
+							packageName = `${parts[0]}/${parts[1]}`;
+							subpathStartIndex = 2;
+						} else {
+							packageName = parts[0];
+							subpathStartIndex = 1;
+						}
+						const subpath = parts.slice(subpathStartIndex).join("/");
+						try {
+							const basePath$1 = importer ? dirname(importer) : process.cwd();
+							resolvedPath = join(dirname(nodeRequire.resolve(`${packageName}/package.json`, { paths: [basePath$1] })), subpath);
+							debugInlineAsset("Manually resolved package import:", resolvedPath);
+						} catch (err) {
+							debugInlineAsset("Failed to manually resolve:", err);
+						}
+					}
+				}
+				if (!resolvedPath) {
+					debugInlineAsset("Could not resolve path:", basePath, "- returning null");
+					return null;
+				}
+				if (!existsSync(resolvedPath)) {
+					debugInlineAsset("Resolved path does not exist:", resolvedPath, "- returning null");
+					return null;
+				}
+				debugInlineAsset("Resolved to:", resolvedPath);
+				let queryParam;
+				if (isInlineAsset) queryParam = "inline-asset-resolved";
+				else queryParam = "no-transform-resolved";
+				const resolvedId = `${resolvedPath}?${queryParam}`;
+				debugInlineAsset("Returning resolved ID:", resolvedId);
+				return {
+					id: resolvedId,
+					external: false
+				};
+			}
+		},
+		load(id) {
+			const isInlineAsset = id.includes("?inline-asset-resolved");
+			const isNoTransform = id.includes("?no-transform-resolved");
+			if (!isInlineAsset && !isNoTransform) return null;
+			let path = id.split("?")[0];
+			if (path.startsWith("/@fs/")) path = path.slice(4);
+			if (path.startsWith("\0")) path = path.slice(1);
+			debugInlineAsset("Loading file:", path, {
+				isInlineAsset,
+				isNoTransform
+			});
+			if (!existsSync(path)) throw new Error(`[inline-asset] File not found: ${path}`);
+			const fileContent = readFileSync(path);
+			debugInlineAsset("Read file:", path, `(${fileContent.length} bytes)`);
+			const isTestMode = typeof process !== "undefined" && (process.env.VITEST || process.env.NODE_ENV === "test");
+			debugInlineAsset("Test mode:", isTestMode, "Dev mode:", isDevMode);
+			if (isTestMode || isDevMode) {
+				debugInlineAsset("Using data URL for", isTestMode ? "test" : "dev", "mode:", basename(path));
+				const base64 = fileContent.toString("base64");
+				const dataUrl = `data:${{
+					js: "application/javascript",
+					mjs: "application/javascript",
+					wasm: "application/wasm",
+					json: "application/json",
+					css: "text/css",
+					html: "text/html",
+					ts: "application/typescript",
+					dts: "application/typescript"
+				}[path.split(".").pop() || ""] || "application/octet-stream"};base64,${base64}`;
+				debugInlineAsset("Returning data URL, length:", dataUrl.length);
+				return {
+					code: `export default ${JSON.stringify(dataUrl)};`,
+					map: {
+						version: 3,
+						sources: [path],
+						mappings: ""
+					}
+				};
+			}
+			const hash = createHash("sha256").update(fileContent).digest("hex").slice(0, 8);
+			const ext = path.split(".").pop() || "bin";
+			const fileName = `${basename(path, `.${ext}`)}-${hash}.${ext}`;
+			const outputPath = join(assetDir, fileName);
+			try {
+				writeFileSync(outputPath, fileContent);
+				debugInlineAsset("Wrote asset file:", outputPath);
+			} catch (err) {
+				throw new Error(`[inline-asset] Failed to write file ${outputPath}`, { cause: err });
+			}
+			const publicPrefixRegex = createRegExp(exactly("public/").at.lineStart());
+			const publicUrl = `/${outDir.replace(publicPrefixRegex, "")}/${fileName}`;
+			debugInlineAsset("Returning public URL:", publicUrl);
+			return {
+				code: `export default ${JSON.stringify(publicUrl)};`,
+				map: {
+					version: 3,
+					sources: [path],
+					mappings: ""
+				}
+			};
+		}
+	};
+};
+
+//#endregion
+export { inlineAsset };

package/lib/rolldown/playground.qwik.mjs

@@ -0,0 +1,67 @@
+import { createRegExp, exactly } from "magic-regexp";
+import MagicString from "magic-string";
+import { walk } from "oxc-walker";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, join } from "node:path";
+import { remark } from "remark";
+import remarkMdx from "remark-mdx";
+
+//#region rolldown/playground.ts
+const playground = () => {
+	const isMDX = createRegExp(exactly(".").and("mdx").at.lineEnd());
+	return {
+		name: "vite-plugin-qds-playground",
+		enforce: "pre",
+		async transform(code, id) {
+			if (!isMDX.test(id)) return;
+			try {
+				const mdast = remark().use(remarkMdx).parse(code);
+				const s = new MagicString(code);
+				let hasPlayground = false;
+				const scenariosDir = join(dirname(id), "scenarios");
+				if (!existsSync(scenariosDir) || !statSync(scenariosDir).isDirectory()) return null;
+				const scenarioFiles = readdirSync(scenariosDir).filter((file) => file.endsWith(".tsx") || file.endsWith(".ts")).map((file) => {
+					const name = basename(file, extname(file));
+					return {
+						name,
+						file,
+						componentVar: `Scenario_${name.replace(/[^a-zA-Z0-9]/g, "_")}`,
+						sourceVar: `Source_${name.replace(/[^a-zA-Z0-9]/g, "_")}`
+					};
+				});
+				if (scenarioFiles.length === 0) return null;
+				walk(mdast, { enter(node) {
+					const mdxNode = node;
+					if ((mdxNode.type === "mdxJsxFlowElement" || mdxNode.type === "mdxJsxTextElement") && mdxNode.name === "Playground") {
+						if (mdxNode.position?.start?.offset !== void 0 && mdxNode.position?.end?.offset !== void 0) {
+							if (!mdxNode.attributes.some((attr) => attr.name === "scenarios")) {
+								const scenariosArrayString = `[${scenarioFiles.map((s$1) => `{name: "${s$1.name}", component: ${s$1.componentVar}, source: ${s$1.sourceVar}}`).join(", ")}]`;
+								const insertPos$1 = mdxNode.position.start.offset + 11;
+								s.appendLeft(insertPos$1, ` scenarios={${scenariosArrayString}}`);
+								hasPlayground = true;
+							}
+						}
+					}
+				} });
+				if (!hasPlayground) return null;
+				const imports = scenarioFiles.map((file) => `import ${file.componentVar} from "./scenarios/${file.file}";\nimport ${file.sourceVar} from "./scenarios/${file.file}?raw";`).join("\n");
+				let insertPos = 0;
+				if (code.startsWith("---")) {
+					const secondDelimiter = code.indexOf("---", 3);
+					if (secondDelimiter !== -1) insertPos = secondDelimiter + 3;
+				}
+				s.appendLeft(insertPos, `\n${imports}\n`);
+				return {
+					code: s.toString(),
+					map: s.generateMap({ hires: true })
+				};
+			} catch (error) {
+				console.error(`Error transforming Playground in ${id}:`, error);
+				return null;
+			}
+		}
+	};
+};
+
+//#endregion
+export { playground };

package/lib/vite/index.qwik.mjs

@@ -1,6 +1,7 @@
 import { asChild } from "../rolldown/as-child.qwik.mjs";
 import { icons } from "../rolldown/icons.qwik.mjs";
+import { inlineAsset } from "../rolldown/inline-asset.qwik.mjs";
 import "../rolldown/index.qwik.mjs";
 import { minifyContentPlugin } from "./minify-content.qwik.mjs";
 
-export { asChild, icons, minifyContentPlugin };
+export { asChild, icons, inlineAsset, minifyContentPlugin };

package/lib/vite/minify-content.qwik.mjs

@@ -8,15 +8,16 @@ import { transform } from "oxc-transform";
 /**
 * This plugin strips types, then minifies the contents of files with the ".script." extension. We watch the components library files and update the injected scripts when the contents change. Useful for dynamic client-only code without waking up the Qwik runtime.
 */ function minifyContentPlugin(options) {
+	const isTestMode = typeof process !== "undefined" && (process.env.VITEST || process.env.NODE_ENV === "test");
 	const scriptsMap = {};
 	const outputFileName = options?.outputFileName || "injected-scripts.ts";
 	const outputTsPath = resolve(options?.outputDir || process.cwd(), outputFileName);
 	const partString = `.${options?.part || "script"}.`;
 	const scriptExtension = createRegExp(exactly(partString).and(oneOrMore(char)).at.lineEnd());
 	const processMap = async (id, code) => {
-		const basename = id.split(sep).join("/").split("/").pop() || "";
-		if (!scriptExtension.test(basename)) return false;
-		const [name] = basename.split(partString);
+		const basename$1 = id.split(sep).join("/").split("/").pop() || "";
+		if (!scriptExtension.test(basename$1)) return false;
+		const [name] = basename$1.split(partString);
 		if (!name) return false;
 		try {
 			scriptsMap[name] = minifySync(id, (await transform(id, code, { typescript: { onlyRemoveTypeImports: false } })).code, {
@@ -24,6 +25,7 @@ import { transform } from "oxc-transform";
 				mangle: { toplevel: true }
 			}).code;
 			const newFileContent = `export const INJECTED_SCRIPTS = ${JSON.stringify(scriptsMap, null, 2)} as const;`;
+			if (isTestMode) return true;
 			let shouldWrite = true;
 			if (existsSync(outputTsPath)) {
 				if (readFileSync(outputTsPath, "utf-8") === newFileContent) shouldWrite = false;
@@ -35,7 +37,7 @@ import { transform } from "oxc-transform";
 			return false;
 		}
 	};
-	if (!existsSync(outputTsPath)) writeFileSync(outputTsPath, "export const INJECTED_SCRIPTS = {} as const;", "utf-8");
+	if (!isTestMode && !existsSync(outputTsPath)) writeFileSync(outputTsPath, "export const INJECTED_SCRIPTS = {} as const;", "utf-8");
 	return {
 		name: "vite-plugin-script-injector",
 		enforce: "pre",

package/lib-types/tools/docs/component-props.d.ts

@@ -0,0 +1,32 @@
+import type { Node } from "@oxc-project/types";
+import type { Plugin as VitePlugin } from "vite";
+export type PropType = {
+    name: string;
+    type: "boolean" | "string" | "number" | "union" | "function" | "unknown";
+    unionValues?: string[];
+    isBindable: boolean;
+    isFunction?: boolean;
+    initialValue?: unknown;
+    comment?: string;
+    scenario?: string;
+};
+export type ComponentPiece = {
+    name: string;
+    props: PropType[];
+};
+export type ComponentMetadata = {
+    componentName: string;
+    pieces: ComponentPiece[];
+};
+export type ComponentPropsPluginOptions = {
+    componentsDir: string;
+    outputDir: string;
+    debug?: boolean;
+};
+export declare const componentProps: (options: ComponentPropsPluginOptions) => VitePlugin;
+export declare function generateAllComponentMetadata(componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
+export declare function generateComponentMetadata(componentName: string, componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
+export declare function extractJSDoc(node: Node, source: string, propName?: string): {
+    comment?: string;
+    scenario?: string;
+};

package/lib-types/tools/docs/component-props.unit.d.ts

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

package/lib-types/tools/docs/generate-metadata.d.ts

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

package/lib-types/tools/docs/generate-metadata.unit.d.ts

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

package/lib-types/tools/docs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./component-props";
+export type { ComponentMetadata, ComponentPiece, PropType } from "./component-props";

package/lib-types/tools/playground/generate-jsx.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentMetadata } from "./prop-extraction";
+export type GenerateJsxOptions = {
+    metadata: ComponentMetadata;
+    selectedPieceName: string;
+    propValues: Record<string, Record<string, unknown>>;
+    isBindProps: boolean;
+    baseSource?: string;
+};
+export declare function generateJsx({ metadata, selectedPieceName, propValues, isBindProps, baseSource }: GenerateJsxOptions): string;

package/lib-types/tools/playground/generate-metadata.d.ts

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

package/lib-types/tools/playground/generate-metadata.unit.d.ts

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

package/lib-types/tools/playground/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin as VitePlugin } from "vite";
+import { type ComponentPropsPluginOptions } from "./prop-extraction";
+export type PlaygroundPluginOptions = ComponentPropsPluginOptions;
+export declare const playground: (options: PlaygroundPluginOptions) => VitePlugin[];
+export type { ComponentMetadata, ComponentPiece, PropType } from "./prop-extraction";

package/lib-types/tools/playground/prop-extraction.d.ts

@@ -0,0 +1,32 @@
+import type { Node } from "@oxc-project/types";
+import type { Plugin as VitePlugin } from "vite";
+export type PropType = {
+    name: string;
+    type: "boolean" | "string" | "number" | "union" | "function" | "unknown";
+    unionValues?: string[];
+    isBindable: boolean;
+    isFunction?: boolean;
+    initialValue?: unknown;
+    comment?: string;
+    scenario?: string;
+};
+export type ComponentPiece = {
+    name: string;
+    props: PropType[];
+};
+export type ComponentMetadata = {
+    componentName: string;
+    pieces: ComponentPiece[];
+};
+export type ComponentPropsPluginOptions = {
+    componentsDir: string;
+    outputDir: string;
+    debug?: boolean;
+};
+export declare const propExtraction: (options: ComponentPropsPluginOptions) => VitePlugin;
+export declare function generateAllComponentMetadata(componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
+export declare function generateComponentMetadata(componentName: string, componentsDir: string, outputDir: string, debug: (message: string, ...data: unknown[]) => void): Promise<void>;
+export declare function extractJSDoc(node: Node, source: string, propName?: string): {
+    comment?: string;
+    scenario?: string;
+};

package/lib-types/tools/playground/prop-extraction.unit.d.ts

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

package/lib-types/tools/playground/scenario-injection.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin as VitePlugin } from "vite";
+export declare const scenarioInjection: () => VitePlugin;

package/lib-types/tools/playground/scenario-injection.unit.d.ts

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

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

@@ -2,5 +2,7 @@ export type { AsChildPluginOptions, AsChildTypes } from "./as-child";
 export { asChild } from "./as-child";
 export type { IconsPluginOptions, PacksMap } from "./icons";
 export { icons } from "./icons";
+export type { InlineAssetPluginOptions } from "./inline-asset";
+export { inlineAsset } from "./inline-asset";
 export { inlineCssPlugin } from "./inline-css";
 export { qwikRolldown } from "./qwik-rolldown";

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

@@ -0,0 +1,18 @@
+import type { Plugin } from "rolldown";
+export type InlineAssetPluginOptions = {
+    debug?: boolean;
+    /** Directory to write inline assets (relative to project root). Defaults to 'public/.qds-inline-assets' */
+    outDir?: string;
+};
+/**
+ * Embeds file content as build-time assets, returning URLs to the inlined content.
+ * Supports both relative paths and package imports (e.g., @qwik.dev/core/dist/...).
+ *
+ * Supports two query parameters:
+ * - `?inline-asset` - Inlines the file content as an asset
+ * - `?no-transform` - Returns raw file content without any transformations
+ *
+ * @param options - Plugin configuration options
+ * @returns Rolldown/Vite-compatible plugin object
+ */
+export declare const inlineAsset: (options?: InlineAssetPluginOptions) => Plugin;

package/lib-types/tools/rolldown/inline-asset.unit.d.ts

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

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

@@ -0,0 +1,8 @@
+export declare const playground: () => {
+    name: string;
+    enforce: "pre";
+    transform(code: string, id: string): Promise<{
+        code: string;
+        map: import("magic-string").SourceMap;
+    } | null | undefined>;
+};

package/lib-types/tools/rolldown/playground.unit.d.ts

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

package/lib-types/tools/src/vite.d.ts

@@ -0,0 +1 @@
+export type { AsChildTypes } from "../vite";

package/lib-types/tools/utils/fs-mock.d.ts

@@ -0,0 +1,17 @@
+export declare const readFile: () => Promise<string>;
+export declare const readFileSync: () => string;
+export declare const existsSync: () => boolean;
+export declare const statSync: () => {};
+export declare const mkdir: () => Promise<void>;
+export declare const readdir: () => Promise<never[]>;
+export declare const writeFile: () => Promise<void>;
+declare const _default: {
+    readFile: () => Promise<string>;
+    readFileSync: () => string;
+    existsSync: () => boolean;
+    statSync: () => {};
+    mkdir: () => Promise<void>;
+    readdir: () => Promise<never[]>;
+    writeFile: () => Promise<void>;
+};
+export default _default;

package/lib-types/tools/vite/index.d.ts

@@ -1,3 +1,4 @@
-export type { AsChildPluginOptions, AsChildTypes, IconsPluginOptions, PacksMap } from "../rolldown";
-export { asChild, icons } from "../rolldown";
+export type { AsChildPluginOptions, AsChildTypes, IconsPluginOptions, InlineAssetPluginOptions, PacksMap } from "../rolldown/index";
+export type { Plugin as VitePlugin, PluginOption as VitePluginOption } from "vite";
+export { asChild, icons, inlineAsset } from "../rolldown/index";
 export { minifyContentPlugin } from "./minify-content";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qds.dev/tools",
-  "version": "0.7.5",
+  "version": "0.8.5",
   "private": false,
   "description": "Tools and utilities for Qwik Design System",
   "type": "module",
@@ -28,6 +28,10 @@
     "./rolldown": {
       "import": "./lib/rolldown/index.qwik.mjs",
       "types": "./lib-types/tools/rolldown/index.d.ts"
+    },
+    "./playground": {
+      "import": "./lib/playground/index.qwik.mjs",
+      "types": "./lib-types/tools/playground/index.d.ts"
     }
   },
   "devDependencies": {
@@ -35,7 +39,7 @@
     "magic-string": "^0.30.17",
     "rolldown": "1.0.0-beta.45",
     "typescript": "5.4.5",
-    "vite": "^7.0.6"
+    "vite": "^7.3.1"
   },
   "dependencies": {
     "@iconify/json": "^2.2.382",