@stencil/unplugin 5.0.0-alpha.16

package/README.md

@@ -0,0 +1,161 @@
+# @stencil/unplugin
+
+Universal bundler plugin for Stencil components — supports Vite, Rollup, Webpack, esbuild, and Rspack.
+
+Lets you import and use Stencil components directly in any bundler without a full Stencil build pipeline. Each `.tsx` component file is transpiled on-the-fly via `transpileSync` into a self-registering custom element.
+
+## Install
+
+```bash
+npm install --save-dev @stencil/unplugin @stencil/core
+```
+
+Optional CSS preprocessors (install only what you need — the plugin silently skips any that aren't present):
+
+```bash
+npm install --save-dev sass          # .scss / .sass
+npm install --save-dev less          # .less
+npm install --save-dev postcss postcss-load-config  # PostCSS via postcss.config.*
+npm install --save-dev lightningcss  # syntax lowering, vendor prefixes, minification
+```
+
+## Usage
+
+### Vite
+
+```ts
+// vite.config.ts
+import { defineConfig } from 'vite';
+import { stencilVite } from '@stencil/unplugin';
+
+export default defineConfig({
+  plugins: [stencilVite()],
+});
+```
+
+### Rollup
+
+```ts
+// rollup.config.js
+import { stencilRollup } from '@stencil/unplugin';
+
+export default {
+  plugins: [stencilRollup()],
+};
+```
+
+### Webpack
+
+```js
+// webpack.config.js
+const { stencilWebpack } = require('@stencil/unplugin');
+
+module.exports = {
+  plugins: [stencilWebpack()],
+};
+```
+
+### esbuild
+
+```ts
+import { build } from 'esbuild';
+import { stencilEsbuild } from '@stencil/unplugin';
+
+await build({
+  plugins: [stencilEsbuild()],
+});
+```
+
+### Rspack
+
+```js
+// rspack.config.js
+const { stencilRspack } = require('@stencil/unplugin');
+
+module.exports = {
+  plugins: [stencilRspack()],
+};
+```
+
+## Options
+
+All options are optional.
+
+```ts
+stencilVite({
+  // Glob/regex patterns of files to transform. Default: [/\.tsx?$/]
+  include: ['src/**/*.tsx'],
+
+  // Glob patterns to exclude. Default: ['node_modules/**']
+  exclude: ['**/*.spec.tsx'],
+
+  // Enable HMR injection. Auto-detected as true in Vite dev mode (command === 'serve').
+  // For webpack/rspack, set true explicitly when running webpack-dev-server or @rspack/dev-server.
+  dev: true,
+
+  // Opt in to docs scanning — see "Docs / CEM" section below.
+  docs: true,
+
+  // Extra options forwarded to transpileSync for every transformed file.
+  // The plugin manages: file, resolveImport, styleImportData, componentExport — don't set those here.
+  transpileOptions: {
+    sourceMap: true,
+  },
+});
+```
+
+| Option | Default | Description |
+|---|---|---|
+| `include` | `[/\.tsx?$/]` | Files to consider for transformation |
+| `exclude` | `['node_modules/**']` | Files to skip |
+| `dev` | `false` (auto in Vite) | Inject HMR client code into component output |
+| `docs` | `false` | Scan and accumulate component metadata for docs/CEM |
+| `transpileOptions` | — | Passed through to `transpileSync` (see `TranspileOptions`) |
+
+## How it works
+
+### Component transform
+
+Only files containing Stencil decorators (`@Component`, `@Prop`, `@State`, etc.) are transformed. Everything else passes through untouched.
+
+Matching files are compiled with `componentExport: 'customelement'`, which means each component self-registers via `customElements.define` (if not already defined) when the module is imported — no separate registration step needed.
+
+### CSS pipeline
+
+Stencil emits style imports with query parameters (e.g. `./my-comp.css?tag=my-comp&encapsulation=shadow`). The plugin intercepts these and runs them through the following pipeline (each step only runs if the peer dep is installed):
+
+1. **Sass / Less** — compile `.scss`, `.sass`, or `.less` to CSS
+2. **PostCSS** — process with `postcss.config.*` if found in the project
+3. **lightningcss** — syntax lowering, vendor prefixes; minification in production
+4. **Scoped rewrite** — scope-prefix selectors for `encapsulation: 'scoped'` components
+
+### HMR
+
+- **Vite**: a `stencil:hmr` WebSocket event is sent when a component file changes. Existing instances in the page are patched in-place without a full reload.
+- **Webpack / Rspack**: uses the `module.hot` re-execution pattern — new class prototype methods are patched onto live instances.
+- Set `dev: true` explicitly for webpack/rspack dev servers; Vite auto-detects it.
+
+## Docs / Custom Elements Manifest
+
+When `docs: true` is set, the plugin scans all component files at build start and accumulates `JsonDocsComponent` metadata as each file is transformed. The aggregate CEM is exposed as a virtual module:
+
+```ts
+// In your app or Storybook preset:
+import cem from '@stencil/unplugin/docs';
+
+console.log(cem.modules); // Custom Elements Manifest
+```
+
+You can also access the CEM programmatically at any point (e.g. from a Node.js build script):
+
+```ts
+import { getStencilCEM, STENCIL_DOCS_ID } from '@stencil/unplugin';
+
+// After the build/transform has run:
+const manifest = getStencilCEM();
+
+// STENCIL_DOCS_ID is the virtual module specifier: '@stencil/unplugin/docs'
+console.log(STENCIL_DOCS_ID);
+```
+
+`getStencilCEM()` returns an empty CEM if `docs: true` was not set on the plugin.

package/dist/docs.d.mts

@@ -0,0 +1,7 @@
+import { CustomElementsManifest } from "@stencil/core/compiler";
+
+//#region src/docs.d.ts
+declare const _default: CustomElementsManifest;
+//#endregion
+export { _default as default };
+//# sourceMappingURL=docs.d.mts.map

package/dist/docs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.mts","names":[],"sources":["../src/docs.ts"],"mappings":";;;cAIqE,QAAA,EAEhD,sBAAsB"}

package/dist/docs.mjs

@@ -0,0 +1,6 @@
+//#region src/docs.ts
+var docs_default = {};
+//#endregion
+export { docs_default as default };
+
+//# sourceMappingURL=docs.mjs.map

package/dist/docs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.mjs","names":[],"sources":["../src/docs.ts"],"sourcesContent":["// Replaced at runtime by the @stencil/unplugin virtual module when the plugin\n// is active (e.g. vite resolveId intercepts '@stencil/unplugin/docs' > '\\0stencil-docs:').\n// This stub exists to provide types and a safe fallback for non-Vite contexts.\n\nimport type { CustomElementsManifest } from '@stencil/core/compiler';\n\nexport default {} as CustomElementsManifest;\n"],"mappings":";AAMA,IAAA,eAAe,CAAC"}

package/dist/index.d.mts

@@ -0,0 +1,74 @@
+import { ConfigCompat, CustomElementsManifest, StencilConfig, TranspileOptions } from "@stencil/core/compiler";
+
+//#region src/options.d.ts
+type TranspileCompatKeys = 'lightDomPatches' | 'lifecycleDOMEvents' | 'initializeNextTick';
+/**
+ * The subset of `stencil.config.ts` fields that affect transpilation.
+ * Derived from {@link StencilConfig} and {@link ConfigCompat} — no parallel docs to maintain.
+ *
+ * Auto-populated from the project's `stencil.config.ts`; values set here override the auto-detected ones.
+ */
+type StencilConfigSubset = Pick<StencilConfig, 'signalBacking'> & {
+  compat?: Pick<ConfigCompat, TranspileCompatKeys>;
+};
+interface StencilPluginOptions {
+  /**
+   * Additional options forwarded to `transpileSync` for every `.tsx`/`.ts` file.
+   * `file`, `resolveImport`, `styleImportData`, and `componentExport` are
+   * managed by the plugin and should not be set here.
+   */
+  transpileOptions?: Omit<TranspileOptions, 'file' | 'resolveImport' | 'styleImportData' | 'componentExport'>;
+  /**
+   * Glob patterns (relative to the project root) for files to include.
+   * Defaults to `['**\/*.tsx']`.
+   */
+  include?: string[];
+  /**
+   * Glob patterns to exclude. Defaults to `['node_modules/**']`.
+   */
+  exclude?: string[];
+  /**
+   * Enable HMR client code injection. Automatically `true` in Vite dev mode
+   * (`command === 'serve'`). For webpack/rspack, set this explicitly when
+   * running with `webpack-dev-server` or `@rspack/dev-server`.
+   */
+  dev?: boolean;
+  /**
+   * When `true`, the plugin scans all component source files at build start and
+   * accumulates per-component `JsonDocsComponent` metadata. The aggregate is
+   * exposed via the `@stencil/unplugin/docs` virtual module and the
+   * `getStencilDocs()` helper.
+   *
+   * Off by default — opt in only when you need docs output (e.g. in a Storybook
+   * preset) to avoid paying the startup scan cost for non-docs builds.
+   */
+  docs?: boolean;
+  /**
+   * Stencil config flags that affect transpilation. The plugin automatically
+   * detects and reads `stencil.config.ts` from the project root — set this only
+   * to override specific values from the auto-detected config.
+   *
+   * Precedence (highest wins):
+   *   `transpileOptions.buildOverrides` > `stencilConfig` > auto-detected config
+   */
+  stencilConfig?: StencilConfigSubset;
+}
+//#endregion
+//#region src/plugin.d.ts
+declare const STENCIL_DOCS_ID = "@stencil/unplugin/docs";
+/**
+ * Returns the current CEM. Only populated when `docs: true` is set.
+ * @returns the current CEM, or an empty CEM if `docs: true` was not set.
+ */
+declare function getStencilCEM(): CustomElementsManifest;
+declare const unpluginStencil: import("unplugin").UnpluginInstance<StencilPluginOptions | undefined, boolean>;
+//#endregion
+//#region src/index.d.ts
+declare const stencilVite: (options?: StencilPluginOptions | undefined) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<any>[];
+declare const stencilRollup: (options?: StencilPluginOptions | undefined) => import("unplugin").RollupPlugin<any> | import("unplugin").RollupPlugin<any>[];
+declare const stencilWebpack: (options?: StencilPluginOptions | undefined) => WebpackPluginInstance;
+declare const stencilEsbuild: (options?: StencilPluginOptions | undefined) => import("unplugin").EsbuildPlugin;
+declare const stencilRspack: (options?: StencilPluginOptions | undefined) => RspackPluginInstance;
+//#endregion
+export { STENCIL_DOCS_ID, type StencilPluginOptions, getStencilCEM, stencilEsbuild, stencilRollup, stencilRspack, stencilVite, stencilWebpack, unpluginStencil };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/options.ts","../src/plugin.ts","../src/index.ts"],"mappings":";;;KAEK,mBAAA;;AAFuF;;;;AAEpE;KAQZ,mBAAA,GAAsB,IAAA,CAAK,aAAA;EACrC,MAAA,GAAS,IAAA,CAAK,YAAA,EAAc,mBAAA;AAAA;AAAA,UAGb,oBAAA;EAJiB;;;;;EAUhC,gBAAA,GAAmB,IAAA,CACjB,gBAAA;EAX8B;;;;EAmBhC,OAAA;EAlB4B;;AAAmB;EAuB/C,OAAA;EApBmC;;;;;EA2BnC,GAAA;EAqBmC;;;;;;;;;EAVnC,IAAA;EAUmC;AAAA;;;;ACjBrC;;;EDiBE,aAAA,GAAgB,mBAAA;AAAA;;;cCjBL,eAAA;AD7C+E;;;;AAAA,iBCwD5E,aAAA,CAAA,GAAiB,sBAAsB;AAAA,cAkD1C,eAAA,qBAAe,gBAAA,CAAA,oBAAA;;;cCrGf,WAAA,GAAW,OAAA,GAAuB,oBAAvB,oCAAA,UAAA,2BAAA,UAAA;AAAA,cACX,aAAA,GAAa,OAAA,GAAyB,oBAAzB,oCAAA,YAAA,2BAAA,YAAA;AAAA,cACb,cAAA,GAAc,OAAA,GAA0B,oBAAA,iBAA1B,qBAA0B;AAAA,cACxC,cAAA,GAAc,OAAA,GAA0B,oBAA1B,oCAAA,aAAA;AAAA,cACd,aAAA,GAAa,OAAA,GAAyB,oBAAA,iBAAzB,oBAAyB"}

package/dist/index.mjs

@@ -0,0 +1,773 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
+import { createFilter } from "@rollup/pluginutils";
+import { cmpMetaToDocsComponent, generateManifest, getScopeId, scopeCss, transpile, transpileSync } from "@stencil/core/compiler";
+import { createUnplugin } from "unplugin";
+import { fileURLToPath } from "node:url";
+import { isPackageExists } from "local-pkg";
+import ts from "typescript";
+//#region src/config.ts
+/**
+* Stencil config auto-detection for @stencil/unplugin.
+*
+* Searches for a `stencil.config.ts` (or `.js` variant) in the project root,
+* loads it via jiti (so TypeScript is handled without a separate compile step),
+* and extracts the subset of flags that are meaningful at transpile time.
+*
+* `stencilConfigToOverrides` converts that subset to a `BuildOverrides` object
+* ready to pass to `transpileSync`.
+*/
+const STENCIL_CONFIG_KEYS = new Set([
+	"namespace",
+	"srcDir",
+	"outputTargets",
+	"plugins",
+	"signalBacking",
+	"compat"
+]);
+const looksLikeConfig = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).some((k) => STENCIL_CONFIG_KEYS.has(k));
+const CONFIG_CANDIDATES = [
+	"stencil.config.ts",
+	"stencil.config.mts",
+	"stencil.config.js",
+	"stencil.config.mjs"
+];
+/**
+* Attempt to load the project's `stencil.config.ts` and return the
+* transpile-relevant fields. Returns `null` if no config file is found or
+* if loading fails for any reason.
+* @param cwd - project root to search in (usually `process.cwd()`)
+* @returns a subset of the Stencil config, or `null` if none is found
+*/
+async function loadStencilConfig(cwd) {
+	for (const filename of CONFIG_CANDIDATES) {
+		const configPath = join(cwd, filename);
+		if (!existsSync(configPath)) continue;
+		try {
+			const { createJiti } = await import("jiti");
+			const mod = await createJiti(import.meta.url).import(configPath);
+			const raw = mod["config"] ?? (looksLikeConfig(mod["default"]) ? mod["default"] : null);
+			if (!raw || typeof raw !== "object") return null;
+			return extractSubset(raw);
+		} catch {
+			return null;
+		}
+	}
+	return null;
+}
+function extractSubset(c) {
+	const result = {};
+	if (c["signalBacking"] === true) result.signalBacking = true;
+	const compat = c["compat"];
+	if (compat && typeof compat === "object") {
+		const co = compat;
+		const ldp = co["lightDomPatches"];
+		const lifecycleDOMEvents = co["lifecycleDOMEvents"];
+		const initializeNextTick = co["initializeNextTick"];
+		if (ldp !== void 0 || lifecycleDOMEvents !== void 0 || initializeNextTick !== void 0) {
+			result.compat = {};
+			if (typeof ldp === "boolean") result.compat.lightDomPatches = ldp;
+			else if (ldp && typeof ldp === "object") result.compat.lightDomPatches = ldp;
+			if (lifecycleDOMEvents === true) result.compat.lifecycleDOMEvents = true;
+			if (initializeNextTick === true) result.compat.initializeNextTick = true;
+		}
+	}
+	return result;
+}
+/**
+* Convert a {@link StencilConfigSubset} to a {@link BuildOverrides} object.
+* The caller is responsible for merging this with any explicit
+* `transpileOptions.buildOverrides` (which should take precedence).
+* @param config - the Stencil config subset to convert
+* @returns a `BuildOverrides` object suitable for passing to `transpileSync`
+*/
+function stencilConfigToOverrides(config) {
+	const o = {};
+	if (config.signalBacking) {
+		o.signalBacking = true;
+		o.vdomSignals = true;
+	}
+	const compat = config.compat;
+	if (!compat) return o;
+	if (compat.lifecycleDOMEvents) o.lifecycleDOMEvents = true;
+	if (compat.initializeNextTick) o.initializeNextTick = true;
+	const ldp = compat.lightDomPatches;
+	if (ldp === false) {
+		o.lightDomPatches = false;
+		o.slotChildNodes = false;
+		o.slotCloneNode = false;
+		o.slotDomMutations = false;
+		o.slotTextContent = false;
+	} else if (typeof ldp === "object") {
+		o.lightDomPatches = true;
+		o.slotChildNodes = !!ldp.childNodes;
+		o.slotCloneNode = !!ldp.cloneNode;
+		o.slotDomMutations = !!ldp.domMutations;
+		o.slotTextContent = !!ldp.textContent;
+	}
+	return o;
+}
+//#endregion
+//#region src/css.ts
+/**
+* CSS pipeline for Stencil component stylesheets.
+*
+* When the Stencil compiler emits a style import such as
+* `./foo.css?tag=my-cmp&encapsulation=shadow`, `resolveStencilCss` rewrites it
+* to a `\0stencil-css:` virtual module ID. The bundler then calls `load`, which
+* reads the real file and runs it through any installed preprocessors in order:
+* Sass/Less → PostCSS → lightningcss → scoped-selector rewrite (for scoped
+* encapsulation). The result is returned as `export default () => "…css…"` so
+* the bundler treats it as a normal JS module dependency.
+*
+* Each preprocessor step is silently skipped if the relevant peer dep is absent.
+*/
+const STENCIL_CSS_RE = /\.(?:css|scss|sass|less|styl)\?[^/]*\btag=/;
+const STENCIL_CSS_PREFIX = "\0stencil-css:";
+const PKG = {
+	sass: isPackageExists("sass"),
+	less: isPackageExists("less"),
+	postcss: isPackageExists("postcss") && isPackageExists("postcss-load-config"),
+	lightningcss: isPackageExists("lightningcss")
+};
+/**
+* Rewrites a Stencil CSS import to a `\0stencil-css:` virtual module ID.
+* The file extension is stored dotless as `__ext` so Vite's `CSS_LANGS_RE`
+* never matches the virtual ID and tries to own the module itself.
+* @param specifier - the raw import specifier from the component source
+* @param importer - absolute path of the importing file
+* @returns virtual module ID, or `null` for non-Stencil CSS imports
+*/
+function resolveStencilCss(specifier, importer) {
+	if (!STENCIL_CSS_RE.test(specifier)) return null;
+	const [base, query] = specifier.split("?");
+	const absBase = resolve(dirname(importer), base);
+	const ext = extname(absBase);
+	return `${STENCIL_CSS_PREFIX}${absBase.slice(0, absBase.length - ext.length)}?${query}&__ext=${encodeURIComponent(ext.slice(1))}`;
+}
+function isStencilCss(id) {
+	return id.startsWith(STENCIL_CSS_PREFIX);
+}
+/**
+* Extracts the real CSS file path from a `\0stencil-css:` virtual module ID.
+* @param id - virtual module ID produced by `resolveStencilCss`
+* @returns absolute file path, or `null` if not a Stencil CSS virtual module
+*/
+function getRealCssPath(id) {
+	if (!id.startsWith(STENCIL_CSS_PREFIX)) return null;
+	const withoutPrefix = id.slice(13);
+	const qIdx = withoutPrefix.indexOf("?");
+	const stem = qIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, qIdx);
+	const query = qIdx === -1 ? "" : withoutPrefix.slice(qIdx + 1);
+	return `${stem}.${decodeURIComponent(new URLSearchParams(query).get("__ext") ?? "css")}`;
+}
+async function compileSass(source, filePath, indented) {
+	const sass = await import("sass");
+	const mainUrl = `file://${filePath}`;
+	const result = sass.compileString(source, {
+		url: new URL(mainUrl),
+		syntax: indented ? "indented" : "scss"
+	});
+	const deps = result.loadedUrls.filter((u) => u.protocol === "file:" && u.href !== mainUrl).map((u) => fileURLToPath(u));
+	return {
+		css: result.css,
+		deps
+	};
+}
+async function compileLess(source, filePath) {
+	const result = await (await import("less")).default.render(source, {
+		filename: filePath,
+		paths: [dirname(filePath)]
+	});
+	return {
+		css: result.css,
+		deps: result.imports ?? []
+	};
+}
+const postcssConfigCache = /* @__PURE__ */ new Map();
+async function runPostCss(css, filePath) {
+	const dir = dirname(filePath);
+	let config = postcssConfigCache.get(dir);
+	if (config === void 0) {
+		try {
+			const { default: loadConfig } = await import("postcss-load-config");
+			const loaded = await loadConfig({}, dir);
+			config = {
+				plugins: loaded.plugins,
+				options: loaded.options
+			};
+		} catch {
+			config = null;
+		}
+		postcssConfigCache.set(dir, config);
+	}
+	if (!config?.plugins.length) return css;
+	const { default: postcss } = await import("postcss");
+	return (await postcss(config.plugins).process(css, {
+		...config.options,
+		from: filePath
+	})).css;
+}
+async function runLightningCss(css, filePath, minify) {
+	const { transform } = await import("lightningcss");
+	return transform({
+		filename: filePath,
+		code: Buffer.from(css),
+		minify
+	}).code.toString();
+}
+/**
+* Loads a Stencil CSS virtual module.
+*
+* Processing order:
+* 1. Read raw file
+* 2. Preprocessor: Sass/SCSS (`sass`) or Less (`less`) if installed
+* 3. PostCSS with `postcss.config.*` if `postcss` + `postcss-load-config` are installed
+* 4. lightningcss if installed — syntax lowering, vendor prefixes, minification in prod
+* 5. Scoped selector rewrite for `encapsulation: 'scoped'`
+*
+* Each step is skipped silently if the relevant peer dep is not installed.
+* Returns `export default "css string"` so bundlers treat the import as a JS module.
+* @param id - virtual module id produced by `resolveStencilCss`
+* @param isDev - `true` in dev mode (disables minification)
+* @returns ESM string export of the processed CSS, or `null` if not a Stencil CSS virtual module
+*/
+async function loadStencilCss(id, isDev = true) {
+	if (!id.startsWith(STENCIL_CSS_PREFIX)) return null;
+	const withoutPrefix = id.slice(13);
+	const qIdx = withoutPrefix.indexOf("?");
+	const stem = qIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, qIdx);
+	const query = qIdx === -1 ? "" : withoutPrefix.slice(qIdx + 1);
+	const params = new URLSearchParams(query);
+	const tag = params.get("tag") ?? "";
+	const encapsulation = params.get("encapsulation") ?? "none";
+	const ext = decodeURIComponent(params.get("__ext") ?? "css");
+	const filePath = `${stem}.${ext}`;
+	if (!existsSync(filePath)) return {
+		code: "export default () => \"\"",
+		deps: []
+	};
+	let css = readFileSync(filePath, "utf-8");
+	let deps = [];
+	if (PKG.sass && (ext === "scss" || ext === "sass")) {
+		const r = await compileSass(css, filePath, ext === "sass");
+		css = r.css;
+		deps = r.deps;
+	} else if (PKG.less && ext === "less") {
+		const r = await compileLess(css, filePath);
+		css = r.css;
+		deps = r.deps;
+	}
+	if (PKG.postcss) css = await runPostCss(css, filePath);
+	if (PKG.lightningcss) css = await runLightningCss(css, filePath, !isDev);
+	if (encapsulation === "scoped" && tag) css = scopeCss(css, getScopeId(tag), false);
+	return {
+		code: `export default () => ${JSON.stringify(css)};`,
+		deps
+	};
+}
+//#endregion
+//#region src/resolve-types.ts
+/**
+* Resolves imported type references in CEM docs components.
+*
+* `transpileSync` uses a single-file TypeScript host, so imported types (e.g.
+* `ButtonVariant` from `'../types'`) can't be followed — `complexType.resolved`
+* ends up as `"any"`. This module creates a minimal ts.Program per referenced
+* types file (cached) and substitutes the actual expanded type text back into
+* the component's doc data before it enters the registry.
+*/
+const TYPE_FORMAT_FLAGS = ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.InTypeAlias | ts.TypeFormatFlags.InElementType;
+const typesFileCache = /* @__PURE__ */ new Map();
+function resolveTypesFilePath(specifier, fromDir) {
+	const base = resolve(fromDir, specifier);
+	if (existsSync(base)) return base;
+	for (const ext of [
+		".ts",
+		".tsx",
+		".d.ts"
+	]) {
+		const candidate = base + ext;
+		if (existsSync(candidate)) return candidate;
+	}
+}
+function getTypesFileEntry(absPath) {
+	const cached = typesFileCache.get(absPath);
+	if (cached) return cached;
+	const options = {
+		...ts.getDefaultCompilerOptions(),
+		noEmit: true,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Bundler
+	};
+	const program = ts.createProgram([absPath], options);
+	const checker = program.getTypeChecker();
+	const sourceFile = program.getSourceFile(absPath);
+	const exportTypes = /* @__PURE__ */ new Map();
+	if (sourceFile) {
+		const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+		if (moduleSymbol) for (const symbol of checker.getExportsOfModule(moduleSymbol)) exportTypes.set(symbol.name, checker.getDeclaredTypeOfSymbol(symbol));
+	}
+	const entry = {
+		checker,
+		exportTypes
+	};
+	typesFileCache.set(absPath, entry);
+	return entry;
+}
+function expandTypeName(typeName, references, fromDir) {
+	const ref = references[typeName];
+	if (!ref || ref.location !== "import" || !ref.path) return void 0;
+	const absPath = resolveTypesFilePath(ref.path, fromDir);
+	if (!absPath) return void 0;
+	const { checker, exportTypes } = getTypesFileEntry(absPath);
+	const type = exportTypes.get(typeName);
+	if (!type) return void 0;
+	return checker.typeToString(type, void 0, TYPE_FORMAT_FLAGS);
+}
+const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function patchType(original, references, fromDir) {
+	if (!references) return original;
+	let result = original;
+	for (const typeName of Object.keys(references)) {
+		const expanded = expandTypeName(typeName, references, fromDir);
+		if (!expanded || expanded === typeName) continue;
+		result = result.replace(new RegExp(`\\b${escapeRegExp(typeName)}\\b`, "g"), expanded.includes("|") || expanded.includes("&") ? `(${expanded})` : expanded);
+	}
+	return result;
+}
+/**
+* Patches `prop.type` and `event.detail` in-place for any imported types that
+* resolved to `"any"` in single-file transpile mode.
+* @param component The CEM docs component to patch
+* @param componentAbsPath The absolute path to the component's source file (used to resolve relative imports)
+*/
+function resolveImportedTypes(component, componentAbsPath) {
+	const dir = dirname(componentAbsPath);
+	for (const prop of component.props) {
+		if (prop.type !== "any" || !prop.complexType?.references) continue;
+		const patched = patchType(prop.complexType.original, prop.complexType.references, dir);
+		if (patched !== prop.complexType.original) prop.type = patched;
+	}
+	for (const event of component.events) {
+		if (event.detail !== "any" || !event.complexType?.references) continue;
+		const patched = patchType(event.complexType.original, event.complexType.references, dir);
+		if (patched !== event.complexType.original) event.detail = patched;
+	}
+}
+//#endregion
+//#region src/transform.ts
+/**
+* Component transpilation and base-class discovery.
+*
+* `transformStencil` is the main entry point: it calls `transpileSync` with
+* `componentExport: 'customelement'` so each component self-registers when
+* imported. Two code paths come out:
+*
+*  - **Component** (`@Component` present): full customelement output with
+*    `defineCustomElement`, optional HMR snippet appended in dev mode.
+*  - **Decorated base class** (`@Prop`/`@State`/etc. but no `@Component`):
+*    returned as-is — the compiler's `isStencilBaseClass` check already injects
+*    `extends HTMLElement` via `updateNativeBaseClass`.
+*
+* `makeResolver` supplies the `resolveImport` callback that `transpileSync`
+* uses during metadata collection. It serves two purposes at once: returning
+* raw source so the compiler can merge inherited props/states into the
+* component's metadata, and calling `onBaseClass` so the plugin can
+* pre-transform and cache the file before the bundler's resolveId hook fires.
+*/
+const SOURCE_EXTS = [
+	".tsx",
+	".ts",
+	".js"
+];
+const JSX_EMIT = {
+	react: 2,
+	"react-jsx": 4,
+	"react-jsxdev": 5,
+	preserve: 1,
+	"react-native": 3
+};
+let cachedTsConfigJsx;
+function readJsxOptsFromTsConfig(cwd) {
+	if (cachedTsConfigJsx !== void 0) return cachedTsConfigJsx;
+	const tsconfigPath = join(cwd, "tsconfig.json");
+	if (!existsSync(tsconfigPath)) return cachedTsConfigJsx = {};
+	try {
+		const stripped = readFileSync(tsconfigPath, "utf-8").replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
+		const co = JSON.parse(stripped)?.compilerOptions ?? {};
+		const jsxStr = co.jsx?.toLowerCase();
+		if (jsxStr && jsxStr in JSX_EMIT) return cachedTsConfigJsx = {
+			jsx: JSX_EMIT[jsxStr],
+			jsxImportSource: co.jsxImportSource
+		};
+	} catch {}
+	return cachedTsConfigJsx = {};
+}
+const IMPORTS_H_RE = /import\s+\{[^}]*\bh\b[^}]*\}\s+from\s+['"]@stencil\/core['"]/;
+function resolveJsxOpts(code, cwd) {
+	const fromTsConfig = readJsxOptsFromTsConfig(cwd);
+	if (fromTsConfig.jsx !== void 0) return fromTsConfig;
+	if (IMPORTS_H_RE.test(code)) return { jsx: JSX_EMIT["react"] };
+	return {
+		jsx: JSX_EMIT["react-jsx"],
+		jsxImportSource: "@stencil/core"
+	};
+}
+/**
+* Resolve an import specifier to an absolute path, trying source extensions
+* and the TypeScript ESM `.js` → `.ts`/`.tsx` remap.
+* @param specifier - the import specifier (relative or extensionless)
+* @param importer - absolute path of the importing file
+* @returns absolute path to the resolved file, or `null` if nothing found on disk
+*/
+function resolveSpecifier(specifier, importer) {
+	const base = resolve(dirname(importer), specifier);
+	const norm = (p) => p.replace(/\\/g, "/");
+	if (existsSync(base)) return norm(base);
+	for (const ext of SOURCE_EXTS) {
+		const candidate = base + ext;
+		if (existsSync(candidate)) return norm(candidate);
+	}
+	if (base.endsWith(".js")) {
+		const stem = base.slice(0, -3);
+		for (const ext of [".ts", ".tsx"]) {
+			const candidate = stem + ext;
+			if (existsSync(candidate)) return norm(candidate);
+		}
+	}
+	return null;
+}
+/**
+* Transpile a `.tsx`/`.ts` file for use in a bundler.
+*
+* Returns `{ code, map, tagName }` for Stencil component or base-class files,
+* `null` for everything else (plain TS utilities, non-TS files, etc.).
+* `tagName` is empty string for base classes with no `@Component`.
+*
+* `onBaseClass` is called for every file the compiler resolves via
+* `resolveImport` during metadata collection. The plugin uses this to
+* pre-transform those files before the bundler's resolveId hook fires.
+* @param code - source file contents
+* @param id - absolute file path
+* @param options - plugin options
+* @param dev - `true` in dev/watch mode (enables HMR snippet)
+* @param framework - active unplugin framework
+* @param onBaseClass - called for each file in the inheritance chain with its abs path and raw source
+* @param configOverrides - pass stencil config option overrides to the transpiler
+* @returns transformed output, or `null` if the file is not a Stencil file
+*/
+function transformStencil(code, id, options, dev = false, framework = "", onBaseClass, configOverrides) {
+	if (!id.endsWith(".tsx") && !id.endsWith(".ts")) return null;
+	if (id.endsWith(".d.ts")) return null;
+	if (!/(@Component|@Prop|@State|@Event|@Method|@Watch|@Listen)\s*[(\s]/.test(code)) return null;
+	const result = transpileSync(code, {
+		...resolveJsxOpts(code, process.cwd()),
+		...options.transpileOptions,
+		file: id,
+		componentExport: "customelement",
+		styleImportData: "queryparams",
+		resolveImport: makeResolver(onBaseClass),
+		buildOverrides: {
+			...configOverrides,
+			...options.transpileOptions?.buildOverrides,
+			...dev ? {
+				hotModuleReplacement: true,
+				isDev: true
+			} : {}
+		}
+	});
+	if (result.diagnostics.some((d) => d.level === "error")) {
+		const msgs = result.diagnostics.filter((d) => d.level === "error").map((d) => d.messageText).join("\n");
+		throw new Error(`[@stencil/unplugin] transpile error in ${id}:\n${msgs}`);
+	}
+	if (!result.data?.length) {
+		if (!/@Component\s*[(\s]/.test(code)) return {
+			code: result.code,
+			map: result.map ?? null,
+			tagName: "",
+			docsComponent: null
+		};
+		return null;
+	}
+	const tagName = result.data[0].tagName;
+	const className = result.data[0].componentClassName;
+	const devExport = dev ? `\nexport{${className}};` : "";
+	const out = dev ? result.code + devExport + buildHmrSnippet(tagName, className, framework) : result.code;
+	const docsComponent = cmpMetaToDocsComponent(result.data[0], id);
+	return {
+		code: out,
+		map: result.map ?? null,
+		tagName,
+		docsComponent
+	};
+}
+/**
+* Transpile a base-class file with `transformAsBaseClass: true` so the
+* compiler injects `extends HTMLElement` into any class without an existing
+* heritage clause, regardless of whether it carries Stencil decorators.
+*
+* The result is cached in `baseClassRegistry` (in plugin.ts) and served as a
+* virtual module, ensuring the bundler always sees the injected version even
+* for plain lifecycle-only classes that the `transform` hook would otherwise skip.
+* @param rawCode - raw source of the base-class file
+* @param absPath - absolute path to the file (used as `file` for source maps)
+* @param options - plugin options forwarded to `transpileSync`
+* @returns compiled JS output
+*/
+function transpileBaseClass(rawCode, absPath, options) {
+	return transpileSync(rawCode, {
+		...options.transpileOptions,
+		file: absPath,
+		componentExport: "customelement",
+		styleImportData: "queryparams",
+		transformAsBaseClass: true
+	}).code;
+}
+function buildHmrSnippet(tagName, className, framework) {
+	const tag = JSON.stringify(tagName);
+	if (framework === "webpack" || framework === "rspack" || framework === "bun") return `\n${className}.__stencil_module__ = import.meta.url;\nvar _sHot = ${framework === "bun" ? "import.meta.hot" : "(typeof module !== 'undefined' && module.hot) || import.meta.webpackHot"};\nif (_sHot) {\n  if (_sHot.data && _sHot.data.stencilHmr) {\n    var _sCtor = customElements.get(${tag});\n    if (_sCtor) Object.getOwnPropertyNames(${className}.prototype).forEach(function(k) {\n      if (k !== 'constructor') Object.defineProperty(_sCtor.prototype, k, Object.getOwnPropertyDescriptor(${className}.prototype, k));\n    });\n    document.querySelectorAll(${tag}).forEach(function(el) { el.connectedCallback && el.connectedCallback(); });\n  }\n  _sHot.dispose(function(data) { data.stencilHmr = true; });\n  _sHot.accept();\n}`;
+	return `\n${className}.__stencil_module__ = import.meta.url;\nif (import.meta.hot && !import.meta.url.includes('s-hmr=')) {\n  import.meta.hot.accept(() => {});\n  import.meta.hot.on('stencil:hmr', function({ tagName }) {\n    if (tagName === ${tag}) {\n      var v = Date.now().toString(36);\n      document.querySelectorAll(${tag}).forEach(function(el) { el['s-hmr'] && el['s-hmr'](v); });\n    }\n  });\n}`;
+}
+function makeResolver(onBaseClass) {
+	return (specifier, currentImporter) => {
+		const absPath = resolveSpecifier(specifier, currentImporter);
+		if (!absPath) return null;
+		const code = readFileSync(absPath, "utf-8");
+		onBaseClass?.(absPath, code);
+		return {
+			code,
+			path: absPath
+		};
+	};
+}
+//#endregion
+//#region src/plugin.ts
+/**
+* Unplugin factory for @stencil/unplugin.
+*
+* Wires together four concerns into a single plugin that works across Vite,
+* Rollup, webpack, rspack, and bun:
+*
+*  1. **Component transform** — `transform` drives `transpileSync` on every
+*     `.tsx`/`.ts` file that carries Stencil decorators, producing
+*     `customelement` output (self-registering class + `defineCustomElement`).
+*
+*  2. **CSS virtual modules** — Stencil emits `./foo.css?tag=my-cmp&…`
+*     imports. `resolveId` rewrites these to `\0stencil-css:` virtual IDs;
+*     `load` reads the real file, runs it through any installed preprocessors,
+*     and returns `export default () => "…css…"`.
+*
+*  3. **Base-class inheritance** — when a component extends a class that does
+*     not itself extend `HTMLElement`, the custom-element registration breaks.
+*     The plugin intercepts every file the compiler resolves via `resolveImport`
+*     (during `transpileSync`), pre-transforms it with `transformAsBaseClass: true`
+*     so it gets `extends HTMLElement`, and caches the result. `resolveId` then
+*     redirects imports of those files to `\0stencil-base:` virtual modules so
+*     the bundler always sees the injected version — regardless of module-graph
+*     processing order.
+*
+*  4. **HMR** — Vite receives a custom `stencil:hmr` WebSocket event when a
+*     component file changes; other bundlers use the `module.hot` re-execution
+*     pattern. CSS changes are covered automatically by `addWatchFile`.
+*/
+const STENCIL_DOCS_ID = "@stencil/unplugin/docs";
+const VIRTUAL_DOCS_PREFIX = "\0stencil-docs:";
+const docsRegistry = /* @__PURE__ */ new Map();
+/**
+* Returns the current CEM. Only populated when `docs: true` is set.
+* @returns the current CEM, or an empty CEM if `docs: true` was not set.
+*/
+function getStencilCEM() {
+	return generateManifest({ components: [...docsRegistry.values()] });
+}
+/**
+* Scan the project for component source files and pre-populate the docs registry.
+* @param filter A function to filter which files should be included.
+* @returns A promise that resolves when the scan is complete.
+*/
+async function scanDocs(filter) {
+	const cwd = process.cwd();
+	let entries;
+	try {
+		entries = readdirSync(cwd, {
+			recursive: true,
+			encoding: "utf-8"
+		});
+	} catch {
+		return;
+	}
+	const files = entries.filter((rel) => (rel.endsWith(".tsx") || rel.endsWith(".ts")) && !rel.endsWith(".d.ts")).map((rel) => join(cwd, rel)).filter((abs) => filter(abs));
+	await Promise.all(files.map(async (abs) => {
+		let code;
+		try {
+			code = readFileSync(abs, "utf-8");
+		} catch {
+			return;
+		}
+		if (!/(@Component|@Prop|@State|@Event|@Method|@Watch|@Listen)\s*[(\s]/.test(code)) return;
+		const result = await transpile(code, {
+			file: abs,
+			componentExport: "customelement"
+		});
+		for (const item of result.data ?? []) {
+			if (!item.tagName) continue;
+			const component = cmpMetaToDocsComponent(item, abs);
+			resolveImportedTypes(component, abs);
+			docsRegistry.set(item.tagName, component);
+		}
+	}));
+}
+const VIRTUAL_BASE_PREFIX = "\0stencil-base:";
+const SIGNALS_IMPORT_RE = /from\s+['"]@stencil\/core\/signals['"]/;
+const unpluginStencil = createUnplugin((options = {}, meta) => {
+	const { framework } = meta;
+	const filter = createFilter(options.include ?? [/\.tsx?$/], options.exclude ?? ["node_modules/**"]);
+	let isDev = options.dev ?? false;
+	let projectRoot = process.cwd();
+	let configOverrides = {};
+	const fileToTagName = /* @__PURE__ */ new Map();
+	const cssFileToTagName = /* @__PURE__ */ new Map();
+	const cssRealToVirtualId = /* @__PURE__ */ new Map();
+	const baseClassRegistry = /* @__PURE__ */ new Map();
+	function registerBaseClass(absPath, rawCode) {
+		if (baseClassRegistry.has(absPath)) return;
+		baseClassRegistry.set(absPath, transpileBaseClass(rawCode, absPath, options));
+	}
+	return {
+		name: "@stencil/unplugin",
+		async buildStart() {
+			const detected = await loadStencilConfig(projectRoot);
+			configOverrides = stencilConfigToOverrides(detected ? {
+				...detected,
+				...options.stencilConfig,
+				compat: {
+					...detected.compat,
+					...options.stencilConfig?.compat
+				}
+			} : options.stencilConfig ?? {});
+			if (options.docs) await scanDocs(filter);
+		},
+		resolveId(id, importer) {
+			if (id === "@stencil/unplugin/docs") return VIRTUAL_DOCS_PREFIX;
+			if (!importer) return null;
+			const css = resolveStencilCss(id, importer);
+			if (css) return css;
+			if (baseClassRegistry.size > 0) {
+				const abs = resolveSpecifier(id, importer.startsWith(VIRTUAL_BASE_PREFIX) ? importer.slice(14) : importer);
+				if (abs && baseClassRegistry.has(abs)) return VIRTUAL_BASE_PREFIX + abs;
+			}
+			return null;
+		},
+		transformInclude(id) {
+			return filter(id.split("?")[0]);
+		},
+		transform(code, id) {
+			const cleanId = id.split("?")[0];
+			if (!configOverrides.vdomSignals && SIGNALS_IMPORT_RE.test(code)) configOverrides = {
+				...configOverrides,
+				vdomSignals: true
+			};
+			const result = transformStencil(code, cleanId, options, isDev, framework, registerBaseClass, configOverrides);
+			if (result?.tagName) fileToTagName.set(cleanId, result.tagName);
+			if (result?.docsComponent && options.docs) {
+				resolveImportedTypes(result.docsComponent, cleanId);
+				docsRegistry.set(result.docsComponent.tag, result.docsComponent);
+			}
+			return result;
+		},
+		loadInclude(id) {
+			return id === VIRTUAL_DOCS_PREFIX || isStencilCss(id) || id.startsWith(VIRTUAL_BASE_PREFIX);
+		},
+		async load(id) {
+			if (id === VIRTUAL_DOCS_PREFIX) return `export default ${JSON.stringify(getStencilCEM())}`;
+			if (id.startsWith(VIRTUAL_BASE_PREFIX)) {
+				const realPath = id.slice(14);
+				this.addWatchFile(realPath);
+				return {
+					code: baseClassRegistry.get(realPath) ?? "",
+					map: null
+				};
+			}
+			const realPath = getRealCssPath(id);
+			const qIdx = id.indexOf("?");
+			const tag = qIdx !== -1 ? new URLSearchParams(id.slice(qIdx + 1)).get("tag") : null;
+			if (realPath) {
+				this.addWatchFile(realPath);
+				if (tag) cssFileToTagName.set(realPath, tag);
+				cssRealToVirtualId.set(realPath, id);
+			}
+			const cssResult = await loadStencilCss(id, isDev);
+			if (cssResult) {
+				if (tag) for (const dep of cssResult.deps) {
+					this.addWatchFile(dep);
+					cssFileToTagName.set(dep, tag);
+					cssRealToVirtualId.set(dep, id);
+				}
+				return {
+					code: cssResult.code,
+					map: null
+				};
+			}
+			return null;
+		},
+		vite: {
+			enforce: "pre",
+			configResolved(config) {
+				isDev = options.dev ?? config.command === "serve";
+				projectRoot = config.root;
+			},
+			async handleHotUpdate({ file, server }) {
+				const tagName = fileToTagName.get(file) ?? cssFileToTagName.get(file);
+				if (!tagName) return;
+				const virtualId = cssRealToVirtualId.get(file);
+				if (virtualId) {
+					const virtualMod = server.moduleGraph.getModuleById?.(virtualId) ?? server.moduleGraph.idToModuleMap?.get(virtualId);
+					if (virtualMod) server.moduleGraph.invalidateModule(virtualMod, /* @__PURE__ */ new Set(), Date.now(), true);
+				}
+				if (options.docs && fileToTagName.has(file)) {
+					let cemChanged = false;
+					try {
+						const prevSnapshot = JSON.stringify(docsRegistry.get(tagName));
+						const result = await transpile(readFileSync(file, "utf-8"), {
+							file,
+							componentExport: "customelement"
+						});
+						for (const item of result.data ?? []) {
+							if (!item.tagName) continue;
+							const component = cmpMetaToDocsComponent(item, file);
+							resolveImportedTypes(component, file);
+							docsRegistry.set(item.tagName, component);
+						}
+						cemChanged = JSON.stringify(docsRegistry.get(tagName)) !== prevSnapshot;
+					} catch {}
+					if (cemChanged) {
+						const docsVirtualMod = server.moduleGraph.getModuleById?.(VIRTUAL_DOCS_PREFIX) ?? server.moduleGraph.idToModuleMap?.get(VIRTUAL_DOCS_PREFIX);
+						if (docsVirtualMod) server.moduleGraph.invalidateModule(docsVirtualMod, /* @__PURE__ */ new Set(), Date.now(), true);
+						server.ws.send({
+							type: "custom",
+							event: "stencil:docs-update"
+						});
+					}
+				}
+				server.ws.send({
+					type: "custom",
+					event: "stencil:hmr",
+					data: { tagName }
+				});
+				return [];
+			}
+		}
+	};
+});
+//#endregion
+//#region src/index.ts
+const stencilVite = unpluginStencil.vite;
+const stencilRollup = unpluginStencil.rollup;
+const stencilWebpack = unpluginStencil.webpack;
+const stencilEsbuild = unpluginStencil.esbuild;
+const stencilRspack = unpluginStencil.rspack;
+//#endregion
+export { STENCIL_DOCS_ID, getStencilCEM, stencilEsbuild, stencilRollup, stencilRspack, stencilVite, stencilWebpack, unpluginStencil };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/config.ts","../src/css.ts","../src/resolve-types.ts","../src/transform.ts","../src/plugin.ts","../src/index.ts"],"sourcesContent":["/**\n * Stencil config auto-detection for @stencil/unplugin.\n *\n * Searches for a `stencil.config.ts` (or `.js` variant) in the project root,\n * loads it via jiti (so TypeScript is handled without a separate compile step),\n * and extracts the subset of flags that are meaningful at transpile time.\n *\n * `stencilConfigToOverrides` converts that subset to a `BuildOverrides` object\n * ready to pass to `transpileSync`.\n */\nimport { existsSync } from 'node:fs';\nimport { join } from 'node:path';\nimport type { BuildOverrides, LightDomPatches } from '@stencil/core/compiler';\n\nimport type { StencilConfigSubset } from './options.js';\n\n// A real Stencil config always has at least one of these keys. Used to\n// distinguish an actual default-exported config from jiti's CJS interop\n// artefact where the module namespace itself lands on `mod.default`.\nconst STENCIL_CONFIG_KEYS = new Set([\n  'namespace',\n  'srcDir',\n  'outputTargets',\n  'plugins',\n  'signalBacking',\n  'compat',\n]);\n\nconst looksLikeConfig = (v: unknown): v is Record<string, unknown> =>\n  v !== null &&\n  typeof v === 'object' &&\n  !Array.isArray(v) &&\n  Object.keys(v as object).some((k) => STENCIL_CONFIG_KEYS.has(k));\n\nconst CONFIG_CANDIDATES = [\n  'stencil.config.ts',\n  'stencil.config.mts',\n  'stencil.config.js',\n  'stencil.config.mjs',\n];\n\n/**\n * Attempt to load the project's `stencil.config.ts` and return the\n * transpile-relevant fields. Returns `null` if no config file is found or\n * if loading fails for any reason.\n * @param cwd - project root to search in (usually `process.cwd()`)\n * @returns a subset of the Stencil config, or `null` if none is found\n */\nexport async function loadStencilConfig(cwd: string): Promise<StencilConfigSubset | null> {\n  for (const filename of CONFIG_CANDIDATES) {\n    const configPath = join(cwd, filename);\n    if (!existsSync(configPath)) continue;\n    try {\n      const { createJiti } = await import('jiti');\n      const jiti = createJiti(import.meta.url);\n      const mod = (await jiti.import(configPath)) as Record<string, unknown>;\n      // Named `config` export is the Stencil convention; fall back to a default\n      // export only when it looks like a real config object (has at least one\n      // known Stencil key) — otherwise jiti's CJS interop may surface the\n      // module namespace object as `default`, which we must not treat as config.\n      const raw = mod['config'] ?? (looksLikeConfig(mod['default']) ? mod['default'] : null);\n      if (!raw || typeof raw !== 'object') return null;\n      return extractSubset(raw as Record<string, unknown>);\n    } catch {\n      return null;\n    }\n  }\n  return null;\n}\n\nfunction extractSubset(c: Record<string, unknown>): StencilConfigSubset {\n  const result: StencilConfigSubset = {};\n  if (c['signalBacking'] === true) result.signalBacking = true;\n  const compat = c['compat'];\n  if (compat && typeof compat === 'object') {\n    const co = compat as Record<string, unknown>;\n    const ldp = co['lightDomPatches'];\n    const lifecycleDOMEvents = co['lifecycleDOMEvents'];\n    const initializeNextTick = co['initializeNextTick'];\n    if (ldp !== undefined || lifecycleDOMEvents !== undefined || initializeNextTick !== undefined) {\n      result.compat = {};\n      if (typeof ldp === 'boolean') result.compat.lightDomPatches = ldp;\n      else if (ldp && typeof ldp === 'object')\n        result.compat.lightDomPatches = ldp as LightDomPatches;\n      if (lifecycleDOMEvents === true) result.compat.lifecycleDOMEvents = true;\n      if (initializeNextTick === true) result.compat.initializeNextTick = true;\n    }\n  }\n  return result;\n}\n\n/**\n * Convert a {@link StencilConfigSubset} to a {@link BuildOverrides} object.\n * The caller is responsible for merging this with any explicit\n * `transpileOptions.buildOverrides` (which should take precedence).\n * @param config - the Stencil config subset to convert\n * @returns a `BuildOverrides` object suitable for passing to `transpileSync`\n */\nexport function stencilConfigToOverrides(config: StencilConfigSubset): BuildOverrides {\n  const o: BuildOverrides = {};\n  if (config.signalBacking) {\n    o.signalBacking = true;\n    o.vdomSignals = true; // signalBacking implies vdomSignals\n  }\n\n  const compat = config.compat;\n  if (!compat) return o;\n  if (compat.lifecycleDOMEvents) o.lifecycleDOMEvents = true;\n  if (compat.initializeNextTick) o.initializeNextTick = true;\n\n  const ldp = compat.lightDomPatches;\n  if (ldp === false) {\n    // Explicitly disable — standalone runtime defaults all to true.\n    o.lightDomPatches = false;\n    o.slotChildNodes = false;\n    o.slotCloneNode = false;\n    o.slotDomMutations = false;\n    o.slotTextContent = false;\n  } else if (typeof ldp === 'object') {\n    // Granular: enable only the named patches; disable the rest (defaults are all-true).\n    o.lightDomPatches = true;\n    o.slotChildNodes = !!ldp.childNodes;\n    o.slotCloneNode = !!ldp.cloneNode;\n    o.slotDomMutations = !!ldp.domMutations;\n    o.slotTextContent = !!ldp.textContent;\n  }\n  // ldp === true or undefined: no-op — already the default in the standalone runtime.\n  return o;\n}\n","/**\n * CSS pipeline for Stencil component stylesheets.\n *\n * When the Stencil compiler emits a style import such as\n * `./foo.css?tag=my-cmp&encapsulation=shadow`, `resolveStencilCss` rewrites it\n * to a `\\0stencil-css:` virtual module ID. The bundler then calls `load`, which\n * reads the real file and runs it through any installed preprocessors in order:\n * Sass/Less → PostCSS → lightningcss → scoped-selector rewrite (for scoped\n * encapsulation). The result is returned as `export default () => \"…css…\"` so\n * the bundler treats it as a normal JS module dependency.\n *\n * Each preprocessor step is silently skipped if the relevant peer dep is absent.\n */\nimport { existsSync, readFileSync } from 'node:fs';\nimport { dirname, extname, resolve } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport { getScopeId, scopeCss } from '@stencil/core/compiler';\nimport { isPackageExists } from 'local-pkg';\n\n// Matches Stencil's emitted style imports: `./foo.css?tag=my-cmp&…`\nconst STENCIL_CSS_RE = /\\.(?:css|scss|sass|less|styl)\\?[^/]*\\btag=/;\nconst STENCIL_CSS_PREFIX = '\\0stencil-css:';\n\n// Evaluated once at startup — avoids repeated filesystem probes per CSS file.\nconst PKG = {\n  sass: isPackageExists('sass'),\n  less: isPackageExists('less'),\n  postcss: isPackageExists('postcss') && isPackageExists('postcss-load-config'),\n  lightningcss: isPackageExists('lightningcss'),\n};\n\n/**\n * Rewrites a Stencil CSS import to a `\\0stencil-css:` virtual module ID.\n * The file extension is stored dotless as `__ext` so Vite's `CSS_LANGS_RE`\n * never matches the virtual ID and tries to own the module itself.\n * @param specifier - the raw import specifier from the component source\n * @param importer - absolute path of the importing file\n * @returns virtual module ID, or `null` for non-Stencil CSS imports\n */\nexport function resolveStencilCss(specifier: string, importer: string): string | null {\n  if (!STENCIL_CSS_RE.test(specifier)) return null;\n  const [base, query] = specifier.split('?');\n  const absBase = resolve(dirname(importer), base);\n  const ext = extname(absBase);\n  const stem = absBase.slice(0, absBase.length - ext.length);\n  return `${STENCIL_CSS_PREFIX}${stem}?${query}&__ext=${encodeURIComponent(ext.slice(1))}`;\n}\n\nexport function isStencilCss(id: string): boolean {\n  return id.startsWith(STENCIL_CSS_PREFIX);\n}\n\n/**\n * Extracts the real CSS file path from a `\\0stencil-css:` virtual module ID.\n * @param id - virtual module ID produced by `resolveStencilCss`\n * @returns absolute file path, or `null` if not a Stencil CSS virtual module\n */\nexport function getRealCssPath(id: string): string | null {\n  if (!id.startsWith(STENCIL_CSS_PREFIX)) return null;\n  const withoutPrefix = id.slice(STENCIL_CSS_PREFIX.length);\n  const qIdx = withoutPrefix.indexOf('?');\n  const stem = qIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, qIdx);\n  const query = qIdx === -1 ? '' : withoutPrefix.slice(qIdx + 1);\n  const ext = decodeURIComponent(new URLSearchParams(query).get('__ext') ?? 'css');\n  return `${stem}.${ext}`;\n}\n\nasync function compileSass(\n  source: string,\n  filePath: string,\n  indented: boolean,\n): Promise<{ css: string; deps: string[] }> {\n  const sass = await import('sass');\n  const mainUrl = `file://${filePath}`;\n  const result = sass.compileString(source, {\n    url: new URL(mainUrl),\n    syntax: indented ? 'indented' : 'scss',\n  });\n  const deps = result.loadedUrls\n    .filter((u) => u.protocol === 'file:' && u.href !== mainUrl)\n    .map((u) => fileURLToPath(u));\n  return { css: result.css, deps };\n}\n\nasync function compileLess(\n  source: string,\n  filePath: string,\n): Promise<{ css: string; deps: string[] }> {\n  const less = await import('less');\n  const result = await less.default.render(source, {\n    filename: filePath,\n    paths: [dirname(filePath)],\n  });\n  return { css: result.css, deps: result.imports ?? [] };\n}\n\n// Cache PostCSS config per directory to avoid repeated filesystem lookups.\nconst postcssConfigCache = new Map<\n  string,\n  { plugins: unknown[]; options: Record<string, unknown> } | null\n>();\n\nasync function runPostCss(css: string, filePath: string): Promise<string> {\n  const dir = dirname(filePath);\n  let config = postcssConfigCache.get(dir);\n\n  if (config === undefined) {\n    try {\n      const { default: loadConfig } = await import('postcss-load-config');\n      const loaded = await loadConfig({}, dir);\n      config = {\n        plugins: loaded.plugins as unknown[],\n        options: loaded.options as Record<string, unknown>,\n      };\n    } catch {\n      config = null;\n    }\n    postcssConfigCache.set(dir, config);\n  }\n\n  if (!config?.plugins.length) return css;\n\n  const { default: postcss } = await import('postcss');\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const result = await postcss(config.plugins as any[]).process(css, {\n    ...config.options,\n    from: filePath,\n  });\n  return result.css;\n}\n\nasync function runLightningCss(css: string, filePath: string, minify: boolean): Promise<string> {\n  const { transform } = await import('lightningcss');\n  const result = transform({\n    filename: filePath,\n    code: Buffer.from(css),\n    minify,\n  });\n  return result.code.toString();\n}\n\n/**\n * Loads a Stencil CSS virtual module.\n *\n * Processing order:\n * 1. Read raw file\n * 2. Preprocessor: Sass/SCSS (`sass`) or Less (`less`) if installed\n * 3. PostCSS with `postcss.config.*` if `postcss` + `postcss-load-config` are installed\n * 4. lightningcss if installed — syntax lowering, vendor prefixes, minification in prod\n * 5. Scoped selector rewrite for `encapsulation: 'scoped'`\n *\n * Each step is skipped silently if the relevant peer dep is not installed.\n * Returns `export default \"css string\"` so bundlers treat the import as a JS module.\n * @param id - virtual module id produced by `resolveStencilCss`\n * @param isDev - `true` in dev mode (disables minification)\n * @returns ESM string export of the processed CSS, or `null` if not a Stencil CSS virtual module\n */\nexport async function loadStencilCss(\n  id: string,\n  isDev = true,\n): Promise<{ code: string; deps: string[] } | null> {\n  if (!id.startsWith(STENCIL_CSS_PREFIX)) return null;\n\n  const withoutPrefix = id.slice(STENCIL_CSS_PREFIX.length);\n  const qIdx = withoutPrefix.indexOf('?');\n  const stem = qIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, qIdx);\n  const query = qIdx === -1 ? '' : withoutPrefix.slice(qIdx + 1);\n  const params = new URLSearchParams(query);\n  const tag = params.get('tag') ?? '';\n  const encapsulation = params.get('encapsulation') ?? 'none';\n  const ext = decodeURIComponent(params.get('__ext') ?? 'css');\n  const filePath = `${stem}.${ext}`;\n\n  if (!existsSync(filePath)) return { code: 'export default () => \"\"', deps: [] };\n\n  let css = readFileSync(filePath, 'utf-8');\n  let deps: string[] = [];\n\n  if (PKG.sass && (ext === 'scss' || ext === 'sass')) {\n    const r = await compileSass(css, filePath, ext === 'sass');\n    css = r.css;\n    deps = r.deps;\n  } else if (PKG.less && ext === 'less') {\n    const r = await compileLess(css, filePath);\n    css = r.css;\n    deps = r.deps;\n  }\n\n  if (PKG.postcss) css = await runPostCss(css, filePath);\n  if (PKG.lightningcss) css = await runLightningCss(css, filePath, !isDev);\n\n  if (encapsulation === 'scoped' && tag) {\n    css = scopeCss(css, getScopeId(tag), false);\n  }\n\n  return { code: `export default () => ${JSON.stringify(css)};`, deps };\n}\n","/**\n * Resolves imported type references in CEM docs components.\n *\n * `transpileSync` uses a single-file TypeScript host, so imported types (e.g.\n * `ButtonVariant` from `'../types'`) can't be followed — `complexType.resolved`\n * ends up as `\"any\"`. This module creates a minimal ts.Program per referenced\n * types file (cached) and substitutes the actual expanded type text back into\n * the component's doc data before it enters the registry.\n */\nimport { existsSync } from 'node:fs';\nimport { dirname, resolve } from 'node:path';\nimport ts from 'typescript';\nimport type { ComponentCompilerTypeReferences, JsonDocsComponent } from '@stencil/core/compiler';\n\nconst TYPE_FORMAT_FLAGS =\n  ts.TypeFormatFlags.NoTruncation |\n  ts.TypeFormatFlags.InTypeAlias |\n  ts.TypeFormatFlags.InElementType;\n\ninterface TypesFileEntry {\n  checker: ts.TypeChecker;\n  exportTypes: Map<string, ts.Type>;\n}\n\nconst typesFileCache = new Map<string, TypesFileEntry>();\n\nfunction resolveTypesFilePath(specifier: string, fromDir: string): string | undefined {\n  const base = resolve(fromDir, specifier);\n  if (existsSync(base)) return base;\n  for (const ext of ['.ts', '.tsx', '.d.ts']) {\n    const candidate = base + ext;\n    if (existsSync(candidate)) return candidate;\n  }\n  return undefined;\n}\n\nfunction getTypesFileEntry(absPath: string): TypesFileEntry {\n  const cached = typesFileCache.get(absPath);\n  if (cached) return cached;\n\n  const options: ts.CompilerOptions = {\n    ...ts.getDefaultCompilerOptions(),\n    noEmit: true,\n    module: ts.ModuleKind.ESNext,\n    moduleResolution: ts.ModuleResolutionKind.Bundler,\n  };\n  const program = ts.createProgram([absPath], options);\n  const checker = program.getTypeChecker();\n  const sourceFile = program.getSourceFile(absPath);\n  const exportTypes = new Map<string, ts.Type>();\n\n  if (sourceFile) {\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      for (const symbol of checker.getExportsOfModule(moduleSymbol)) {\n        exportTypes.set(symbol.name, checker.getDeclaredTypeOfSymbol(symbol));\n      }\n    }\n  }\n\n  const entry: TypesFileEntry = { checker, exportTypes };\n  typesFileCache.set(absPath, entry);\n  return entry;\n}\n\nfunction expandTypeName(\n  typeName: string,\n  references: ComponentCompilerTypeReferences,\n  fromDir: string,\n): string | undefined {\n  const ref = references[typeName];\n  if (!ref || ref.location !== 'import' || !ref.path) return undefined;\n\n  const absPath = resolveTypesFilePath(ref.path, fromDir);\n  if (!absPath) return undefined;\n\n  const { checker, exportTypes } = getTypesFileEntry(absPath);\n  const type = exportTypes.get(typeName);\n  if (!type) return undefined;\n\n  return checker.typeToString(type, undefined, TYPE_FORMAT_FLAGS);\n}\n\nconst escapeRegExp = (s: string) => s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nfunction patchType(\n  original: string,\n  references: ComponentCompilerTypeReferences | undefined,\n  fromDir: string,\n): string {\n  if (!references) return original;\n  let result = original;\n  for (const typeName of Object.keys(references)) {\n    const expanded = expandTypeName(typeName, references, fromDir);\n    if (!expanded || expanded === typeName) continue;\n    // Wrap in parens when substituting into a potentially larger expression\n    // e.g. `ButtonVariant | undefined` → `('sm' | 'md') | undefined`\n    result = result.replace(\n      new RegExp(`\\\\b${escapeRegExp(typeName)}\\\\b`, 'g'),\n      expanded.includes('|') || expanded.includes('&') ? `(${expanded})` : expanded,\n    );\n  }\n  return result;\n}\n\n/**\n * Patches `prop.type` and `event.detail` in-place for any imported types that\n * resolved to `\"any\"` in single-file transpile mode.\n * @param component The CEM docs component to patch\n * @param componentAbsPath The absolute path to the component's source file (used to resolve relative imports)\n */\nexport function resolveImportedTypes(component: JsonDocsComponent, componentAbsPath: string): void {\n  const dir = dirname(componentAbsPath);\n\n  for (const prop of component.props) {\n    if (prop.type !== 'any' || !prop.complexType?.references) continue;\n    const patched = patchType(prop.complexType.original, prop.complexType.references, dir);\n    if (patched !== prop.complexType.original) prop.type = patched;\n  }\n\n  for (const event of component.events) {\n    if (event.detail !== 'any' || !event.complexType?.references) continue;\n    const patched = patchType(event.complexType.original, event.complexType.references, dir);\n    if (patched !== event.complexType.original) event.detail = patched;\n  }\n}\n","/**\n * Component transpilation and base-class discovery.\n *\n * `transformStencil` is the main entry point: it calls `transpileSync` with\n * `componentExport: 'customelement'` so each component self-registers when\n * imported. Two code paths come out:\n *\n *  - **Component** (`@Component` present): full customelement output with\n *    `defineCustomElement`, optional HMR snippet appended in dev mode.\n *  - **Decorated base class** (`@Prop`/`@State`/etc. but no `@Component`):\n *    returned as-is — the compiler's `isStencilBaseClass` check already injects\n *    `extends HTMLElement` via `updateNativeBaseClass`.\n *\n * `makeResolver` supplies the `resolveImport` callback that `transpileSync`\n * uses during metadata collection. It serves two purposes at once: returning\n * raw source so the compiler can merge inherited props/states into the\n * component's metadata, and calling `onBaseClass` so the plugin can\n * pre-transform and cache the file before the bundler's resolveId hook fires.\n */\nimport { existsSync, readFileSync } from 'node:fs';\nimport { dirname, join, resolve } from 'node:path';\nimport { cmpMetaToDocsComponent, transpileSync } from '@stencil/core/compiler';\nimport type { BuildOverrides, JsonDocsComponent } from '@stencil/core/compiler';\nimport type { SupportedFramework } from 'unplugin';\n\nimport type { StencilPluginOptions } from './options.js';\n\nconst SOURCE_EXTS = ['.tsx', '.ts', '.js'];\n\n// TypeScript JsxEmit enum values — stable across TS versions.\nconst JSX_EMIT: Record<string, number> = {\n  react: 2,\n  'react-jsx': 4,\n  'react-jsxdev': 5,\n  preserve: 1,\n  'react-native': 3,\n};\n\ntype JsxOpts = { jsx?: number; jsxImportSource?: string };\n\nlet cachedTsConfigJsx: JsxOpts | undefined;\n\nfunction readJsxOptsFromTsConfig(cwd: string): JsxOpts {\n  if (cachedTsConfigJsx !== undefined) return cachedTsConfigJsx;\n  const tsconfigPath = join(cwd, 'tsconfig.json');\n  if (!existsSync(tsconfigPath)) return (cachedTsConfigJsx = {});\n  try {\n    const raw = readFileSync(tsconfigPath, 'utf-8');\n    const stripped = raw.replace(/\\/\\/[^\\n]*/g, '').replace(/\\/\\*[\\s\\S]*?\\*\\//g, '');\n    const tsconfig = JSON.parse(stripped);\n    const co = tsconfig?.compilerOptions ?? {};\n    const jsxStr: string | undefined = co.jsx?.toLowerCase();\n    if (jsxStr && jsxStr in JSX_EMIT) {\n      return (cachedTsConfigJsx = {\n        jsx: JSX_EMIT[jsxStr],\n        jsxImportSource: co.jsxImportSource,\n      });\n    }\n  } catch {\n    // ignore unreadable / malformed tsconfig\n  }\n  return (cachedTsConfigJsx = {});\n}\n\n// Detects classic JSX mode: `import { …, h, … } from '@stencil/core'`\nconst IMPORTS_H_RE = /import\\s+\\{[^}]*\\bh\\b[^}]*\\}\\s+from\\s+['\"]@stencil\\/core['\"]/;\n\n/* Resolve jsx/jsxImportSource for transpileSync.\n * Priority: tsconfig.json > source heuristic (h import → classic; otherwise automatic runtime). */\nfunction resolveJsxOpts(code: string, cwd: string): JsxOpts {\n  const fromTsConfig = readJsxOptsFromTsConfig(cwd);\n  if (fromTsConfig.jsx !== undefined) return fromTsConfig;\n  if (IMPORTS_H_RE.test(code)) {\n    return { jsx: JSX_EMIT['react'] }; // jsxFactory: 'h' auto-applied by transpile-module\n  }\n  return { jsx: JSX_EMIT['react-jsx'], jsxImportSource: '@stencil/core' };\n}\n\n/**\n * Resolve an import specifier to an absolute path, trying source extensions\n * and the TypeScript ESM `.js` → `.ts`/`.tsx` remap.\n * @param specifier - the import specifier (relative or extensionless)\n * @param importer - absolute path of the importing file\n * @returns absolute path to the resolved file, or `null` if nothing found on disk\n */\nexport function resolveSpecifier(specifier: string, importer: string): string | null {\n  const base = resolve(dirname(importer), specifier);\n  // Vite normalizes module IDs to forward slashes; we must match that so\n  // virtual-module keys stay consistent on Windows.\n  const norm = (p: string) => p.replace(/\\\\/g, '/');\n\n  if (existsSync(base)) return norm(base);\n\n  for (const ext of SOURCE_EXTS) {\n    const candidate = base + ext;\n    if (existsSync(candidate)) return norm(candidate);\n  }\n\n  // TypeScript ESM: `./foo.js` may physically be `./foo.ts` or `./foo.tsx`\n  if (base.endsWith('.js')) {\n    const stem = base.slice(0, -3);\n    for (const ext of ['.ts', '.tsx']) {\n      const candidate = stem + ext;\n      if (existsSync(candidate)) return norm(candidate);\n    }\n  }\n\n  return null;\n}\n\n/**\n * Transpile a `.tsx`/`.ts` file for use in a bundler.\n *\n * Returns `{ code, map, tagName }` for Stencil component or base-class files,\n * `null` for everything else (plain TS utilities, non-TS files, etc.).\n * `tagName` is empty string for base classes with no `@Component`.\n *\n * `onBaseClass` is called for every file the compiler resolves via\n * `resolveImport` during metadata collection. The plugin uses this to\n * pre-transform those files before the bundler's resolveId hook fires.\n * @param code - source file contents\n * @param id - absolute file path\n * @param options - plugin options\n * @param dev - `true` in dev/watch mode (enables HMR snippet)\n * @param framework - active unplugin framework\n * @param onBaseClass - called for each file in the inheritance chain with its abs path and raw source\n * @param configOverrides - pass stencil config option overrides to the transpiler\n * @returns transformed output, or `null` if the file is not a Stencil file\n */\nexport function transformStencil(\n  code: string,\n  id: string,\n  options: StencilPluginOptions,\n  dev = false,\n  framework: SupportedFramework | '' = '',\n  onBaseClass?: (absPath: string, rawCode: string) => void,\n  configOverrides?: BuildOverrides,\n): {\n  code: string;\n  map: string | null;\n  tagName: string;\n  docsComponent: JsonDocsComponent | null;\n} | null {\n  if (!id.endsWith('.tsx') && !id.endsWith('.ts')) return null;\n  if (id.endsWith('.d.ts')) return null;\n\n  // Cheap regex guard — avoids paying transpileSync cost for plain TS files.\n  if (!/(@Component|@Prop|@State|@Event|@Method|@Watch|@Listen)\\s*[(\\s]/.test(code)) return null;\n\n  const jsxOpts = resolveJsxOpts(code, process.cwd());\n  const result = transpileSync(code, {\n    ...jsxOpts,\n    ...options.transpileOptions,\n    file: id,\n    componentExport: 'customelement',\n    styleImportData: 'queryparams',\n    resolveImport: makeResolver(onBaseClass),\n    buildOverrides: {\n      ...configOverrides,\n      ...options.transpileOptions?.buildOverrides,\n      ...(dev ? { hotModuleReplacement: true, isDev: true } : {}),\n    },\n  });\n\n  if (result.diagnostics.some((d) => d.level === 'error')) {\n    const msgs = result.diagnostics\n      .filter((d) => d.level === 'error')\n      .map((d) => d.messageText)\n      .join('\\n');\n    throw new Error(`[@stencil/unplugin] transpile error in ${id}:\\n${msgs}`);\n  }\n\n  if (!result.data?.length) {\n    // No @Component — this is a base class or mixin factory. Return the\n    // compiled output; for decorated classes the compiler's isStencilBaseClass\n    // check already injected `extends HTMLElement`. Plain classes without\n    // decorators are handled via the baseClassRegistry virtual-module path.\n    if (!/@Component\\s*[(\\s]/.test(code)) {\n      return { code: result.code, map: result.map ?? null, tagName: '', docsComponent: null };\n    }\n    return null;\n  }\n\n  const tagName = result.data[0].tagName;\n  const className = result.data[0].componentClassName;\n\n  // In dev mode, re-export the class so hmrStandalone can find it in the\n  // re-imported module (customelement mode strips the export keyword).\n  const devExport = dev ? `\\nexport{${className}};` : '';\n  const out = dev\n    ? result.code + devExport + buildHmrSnippet(tagName, className, framework)\n    : result.code;\n\n  const docsComponent = cmpMetaToDocsComponent(result.data[0], id);\n\n  return { code: out, map: result.map ?? null, tagName, docsComponent };\n}\n\n/**\n * Transpile a base-class file with `transformAsBaseClass: true` so the\n * compiler injects `extends HTMLElement` into any class without an existing\n * heritage clause, regardless of whether it carries Stencil decorators.\n *\n * The result is cached in `baseClassRegistry` (in plugin.ts) and served as a\n * virtual module, ensuring the bundler always sees the injected version even\n * for plain lifecycle-only classes that the `transform` hook would otherwise skip.\n * @param rawCode - raw source of the base-class file\n * @param absPath - absolute path to the file (used as `file` for source maps)\n * @param options - plugin options forwarded to `transpileSync`\n * @returns compiled JS output\n */\nexport function transpileBaseClass(\n  rawCode: string,\n  absPath: string,\n  options: StencilPluginOptions,\n): string {\n  const result = transpileSync(rawCode, {\n    ...options.transpileOptions,\n    file: absPath,\n    componentExport: 'customelement',\n    styleImportData: 'queryparams',\n    transformAsBaseClass: true,\n  });\n  return result.code;\n}\n\n/* Builds the HMR client snippet appended to component output in dev mode.\n *\n * Two strategies depending on bundler:\n * - Vite / Farm: server sends a `stencil:hmr` WebSocket event via\n *   `handleHotUpdate`; the client calls `el['s-hmr'](version)` which triggers\n *   a cache-busted re-import and forced re-render.\n * - webpack / rspack / bun: use the `module.hot` re-execution pattern —\n *   `dispose` marks the reload with a flag, `accept` re-runs the module, and\n *   the new prototype is patched onto existing instances in-place. */\nfunction buildHmrSnippet(\n  tagName: string,\n  className: string,\n  framework: SupportedFramework | '',\n): string {\n  const tag = JSON.stringify(tagName);\n\n  if (framework === 'webpack' || framework === 'rspack' || framework === 'bun') {\n    const hotExpr =\n      framework === 'bun'\n        ? 'import.meta.hot'\n        : \"(typeof module !== 'undefined' && module.hot) || import.meta.webpackHot\";\n\n    return (\n      `\\n${className}.__stencil_module__ = import.meta.url;` +\n      `\\nvar _sHot = ${hotExpr};` +\n      `\\nif (_sHot) {` +\n      `\\n  if (_sHot.data && _sHot.data.stencilHmr) {` +\n      `\\n    var _sCtor = customElements.get(${tag});` +\n      `\\n    if (_sCtor) Object.getOwnPropertyNames(${className}.prototype).forEach(function(k) {` +\n      `\\n      if (k !== 'constructor') Object.defineProperty(_sCtor.prototype, k, Object.getOwnPropertyDescriptor(${className}.prototype, k));` +\n      `\\n    });` +\n      `\\n    document.querySelectorAll(${tag}).forEach(function(el) { el.connectedCallback && el.connectedCallback(); });` +\n      `\\n  }` +\n      `\\n  _sHot.dispose(function(data) { data.stencilHmr = true; });` +\n      `\\n  _sHot.accept();` +\n      `\\n}`\n    );\n  }\n\n  // Vite and Farm both implement the Vite HMR API.\n  // The s-hmr guard prevents ?s-hmr= re-imports from stacking up additional listeners.\n  return (\n    `\\n${className}.__stencil_module__ = import.meta.url;` +\n    `\\nif (import.meta.hot && !import.meta.url.includes('s-hmr=')) {` +\n    `\\n  import.meta.hot.accept(() => {});` +\n    `\\n  import.meta.hot.on('stencil:hmr', function({ tagName }) {` +\n    `\\n    if (tagName === ${tag}) {` +\n    `\\n      var v = Date.now().toString(36);` +\n    `\\n      document.querySelectorAll(${tag}).forEach(function(el) { el['s-hmr'] && el['s-hmr'](v); });` +\n    `\\n    }` +\n    `\\n  });` +\n    `\\n}`\n  );\n}\n\n/* Builds the `resolveImport` callback for `transpileSync`.\n *\n * The compiler calls this for every import it encounters while walking the\n * inheritance chain during metadata collection. The callback returns the raw\n * source so the compiler can merge inherited props/states/events into the\n * component's metadata. As a side-effect it calls `onBaseClass` with the same\n * raw source, giving the plugin a chance to pre-transform and cache the file\n * before the bundler's resolveId hook fires for it. */\nfunction makeResolver(onBaseClass?: (absPath: string, rawCode: string) => void) {\n  return (specifier: string, currentImporter: string): { code: string; path: string } | null => {\n    const absPath = resolveSpecifier(specifier, currentImporter);\n    if (!absPath) return null;\n\n    const code = readFileSync(absPath, 'utf-8');\n    onBaseClass?.(absPath, code);\n    return { code, path: absPath };\n  };\n}\n","/**\n * Unplugin factory for @stencil/unplugin.\n *\n * Wires together four concerns into a single plugin that works across Vite,\n * Rollup, webpack, rspack, and bun:\n *\n *  1. **Component transform** — `transform` drives `transpileSync` on every\n *     `.tsx`/`.ts` file that carries Stencil decorators, producing\n *     `customelement` output (self-registering class + `defineCustomElement`).\n *\n *  2. **CSS virtual modules** — Stencil emits `./foo.css?tag=my-cmp&…`\n *     imports. `resolveId` rewrites these to `\\0stencil-css:` virtual IDs;\n *     `load` reads the real file, runs it through any installed preprocessors,\n *     and returns `export default () => \"…css…\"`.\n *\n *  3. **Base-class inheritance** — when a component extends a class that does\n *     not itself extend `HTMLElement`, the custom-element registration breaks.\n *     The plugin intercepts every file the compiler resolves via `resolveImport`\n *     (during `transpileSync`), pre-transforms it with `transformAsBaseClass: true`\n *     so it gets `extends HTMLElement`, and caches the result. `resolveId` then\n *     redirects imports of those files to `\\0stencil-base:` virtual modules so\n *     the bundler always sees the injected version — regardless of module-graph\n *     processing order.\n *\n *  4. **HMR** — Vite receives a custom `stencil:hmr` WebSocket event when a\n *     component file changes; other bundlers use the `module.hot` re-execution\n *     pattern. CSS changes are covered automatically by `addWatchFile`.\n */\nimport { readdirSync, readFileSync } from 'node:fs';\nimport { join } from 'node:path';\nimport { createFilter } from '@rollup/pluginutils';\nimport { transpile, cmpMetaToDocsComponent, generateManifest } from '@stencil/core/compiler';\nimport { createUnplugin } from 'unplugin';\nimport type {\n  BuildOverrides,\n  CustomElementsManifest,\n  JsonDocsComponent,\n} from '@stencil/core/compiler';\n\nimport { loadStencilConfig, stencilConfigToOverrides } from './config.js';\nimport { getRealCssPath, isStencilCss, loadStencilCss, resolveStencilCss } from './css.js';\nimport { resolveImportedTypes } from './resolve-types.js';\nimport { resolveSpecifier, transformStencil, transpileBaseClass } from './transform.js';\nimport type { StencilPluginOptions } from './options.js';\n\nexport const STENCIL_DOCS_ID = '@stencil/unplugin/docs';\nconst VIRTUAL_DOCS_PREFIX = '\\0stencil-docs:';\n\n// Module-level registry so getStencilDocs() is callable from outside the plugin\n// (e.g. from a Storybook preset running in Node.js).\nconst docsRegistry = new Map<string, JsonDocsComponent>();\n\n/**\n * Returns the current CEM. Only populated when `docs: true` is set.\n * @returns the current CEM, or an empty CEM if `docs: true` was not set.\n */\nexport function getStencilCEM(): CustomElementsManifest {\n  return generateManifest({ components: [...docsRegistry.values()] });\n}\n\n/**\n * Scan the project for component source files and pre-populate the docs registry.\n * @param filter A function to filter which files should be included.\n * @returns A promise that resolves when the scan is complete.\n */\nasync function scanDocs(filter: (id: string) => boolean): Promise<void> {\n  const cwd = process.cwd();\n  let entries: string[];\n  try {\n    entries = readdirSync(cwd, { recursive: true, encoding: 'utf-8' }) as string[];\n  } catch {\n    return;\n  }\n\n  const files = entries\n    .filter((rel) => (rel.endsWith('.tsx') || rel.endsWith('.ts')) && !rel.endsWith('.d.ts'))\n    .map((rel) => join(cwd, rel))\n    .filter((abs) => filter(abs));\n\n  await Promise.all(\n    files.map(async (abs) => {\n      let code: string;\n      try {\n        code = readFileSync(abs, 'utf-8');\n      } catch {\n        return;\n      }\n      if (!/(@Component|@Prop|@State|@Event|@Method|@Watch|@Listen)\\s*[(\\s]/.test(code)) return;\n      const result = await transpile(code, { file: abs, componentExport: 'customelement' });\n      for (const item of result.data ?? []) {\n        if (!item.tagName) continue;\n        const component = cmpMetaToDocsComponent(item, abs);\n        resolveImportedTypes(component, abs);\n        docsRegistry.set(item.tagName, component);\n      }\n    }),\n  );\n}\n\n// Null-byte prefix marks a virtual module — Rollup/Vite convention that\n// prevents the ID from being treated as a real filesystem path.\nconst VIRTUAL_BASE_PREFIX = '\\0stencil-base:';\n\n// Mirrors the compiler's hasSignalsImport check in static-to-meta/import.ts.\nconst SIGNALS_IMPORT_RE = /from\\s+['\"]@stencil\\/core\\/signals['\"]/;\n\nexport const unpluginStencil = createUnplugin(\n  (options: StencilPluginOptions | undefined = {}, meta) => {\n    const { framework } = meta;\n    const filter = createFilter(\n      options.include ?? [/\\.tsx?$/],\n      options.exclude ?? ['node_modules/**'],\n    );\n\n    // Vite auto-detects dev mode via configResolved; other bundlers use options.dev.\n    let isDev = options.dev ?? false;\n\n    // For Vite, configResolved sets this to config.root (more accurate than process.cwd()).\n    // For other bundlers, process.cwd() is the fallback.\n    let projectRoot = process.cwd();\n\n    // Merged BUILD overrides from auto-detected stencil.config + explicit stencilConfig.\n    // Populated in buildStart; explicit transpileOptions.buildOverrides takes precedence\n    // over this in transformStencil.\n    let configOverrides: BuildOverrides = {};\n\n    // Tracks which source file owns which custom-element tag name, used by the\n    // Vite HMR handler to send targeted `stencil:hmr` events.\n    const fileToTagName = new Map<string, string>();\n\n    // Maps CSS dependency paths (including Sass @use/@import) → tag name so\n    // changes to imported partials also trigger HMR for the component.\n    const cssFileToTagName = new Map<string, string>();\n\n    // Maps real CSS file path → virtual CSS module ID (\\0stencil-css:...) so\n    // handleHotUpdate can locate and invalidate the right module in the graph.\n    const cssRealToVirtualId = new Map<string, string>();\n\n    // absPath → HTMLElement-injected JS. Populated during `transform` when\n    // `transpileSync`'s resolveImport callback discovers a base-class file.\n    // Rollup guarantees that resolveId for imports in a module's *output* fires\n    // after the transform that produced them — so by the time the bundler asks\n    // to resolve a base-class import, this map is already populated.\n    const baseClassRegistry = new Map<string, string>();\n\n    function registerBaseClass(absPath: string, rawCode: string) {\n      if (baseClassRegistry.has(absPath)) return; // already processed this build\n      baseClassRegistry.set(absPath, transpileBaseClass(rawCode, absPath, options));\n    }\n\n    return {\n      name: '@stencil/unplugin',\n\n      async buildStart() {\n        const detected = await loadStencilConfig(projectRoot);\n        // Merge: auto-detected config is the base; explicit stencilConfig overrides field-by-field.\n        const merged = detected\n          ? {\n              ...detected,\n              ...options.stencilConfig,\n              compat: { ...detected.compat, ...options.stencilConfig?.compat },\n            }\n          : (options.stencilConfig ?? {});\n        configOverrides = stencilConfigToOverrides(merged);\n        if (options.docs) await scanDocs(filter);\n      },\n\n      resolveId(id, importer) {\n        if (id === STENCIL_DOCS_ID) return VIRTUAL_DOCS_PREFIX;\n        if (!importer) return null;\n\n        const css = resolveStencilCss(id, importer);\n        if (css) return css;\n\n        if (baseClassRegistry.size > 0) {\n          // Imports inside a virtual base-class module use the virtual ID as\n          // importer — strip the prefix so resolveSpecifier works against the\n          // real path on disk. This matters for multi-level inheritance chains.\n\n          const realImporter = importer.startsWith(VIRTUAL_BASE_PREFIX)\n            ? importer.slice(VIRTUAL_BASE_PREFIX.length)\n            : importer;\n\n          const abs = resolveSpecifier(id, realImporter);\n          if (abs && baseClassRegistry.has(abs)) {\n            return VIRTUAL_BASE_PREFIX + abs;\n          }\n        }\n\n        return null;\n      },\n\n      transformInclude(id) {\n        return filter(id.split('?')[0]);\n      },\n\n      transform(code, id) {\n        const cleanId = id.split('?')[0];\n        if (!configOverrides.vdomSignals && SIGNALS_IMPORT_RE.test(code)) {\n          configOverrides = { ...configOverrides, vdomSignals: true };\n        }\n        const result = transformStencil(\n          code,\n          cleanId,\n          options,\n          isDev,\n          framework,\n          registerBaseClass,\n          configOverrides,\n        );\n        if (result?.tagName) fileToTagName.set(cleanId, result.tagName);\n        if (result?.docsComponent && options.docs) {\n          resolveImportedTypes(result.docsComponent, cleanId);\n          docsRegistry.set(result.docsComponent.tag, result.docsComponent);\n        }\n        return result;\n      },\n\n      loadInclude(id) {\n        return id === VIRTUAL_DOCS_PREFIX || isStencilCss(id) || id.startsWith(VIRTUAL_BASE_PREFIX);\n      },\n\n      async load(id) {\n        if (id === VIRTUAL_DOCS_PREFIX) {\n          return `export default ${JSON.stringify(getStencilCEM())}`;\n        }\n        if (id.startsWith(VIRTUAL_BASE_PREFIX)) {\n          const realPath = id.slice(VIRTUAL_BASE_PREFIX.length);\n          this.addWatchFile(realPath); // re-invalidate this virtual module when the source changes\n          return { code: baseClassRegistry.get(realPath) ?? '', map: null };\n        }\n        const realPath = getRealCssPath(id);\n        const qIdx = id.indexOf('?');\n        const tag = qIdx !== -1 ? new URLSearchParams(id.slice(qIdx + 1)).get('tag') : null;\n        if (realPath) {\n          this.addWatchFile(realPath);\n          if (tag) cssFileToTagName.set(realPath, tag);\n          cssRealToVirtualId.set(realPath, id);\n        }\n        const cssResult = await loadStencilCss(id, isDev);\n        if (cssResult) {\n          if (tag) {\n            for (const dep of cssResult.deps) {\n              this.addWatchFile(dep);\n              cssFileToTagName.set(dep, tag);\n              cssRealToVirtualId.set(dep, id);\n            }\n          }\n          return { code: cssResult.code, map: null };\n        }\n        return null;\n      },\n\n      vite: {\n        // Must run before Vite/rolldown's built-in TSX transform, which would\n        // otherwise claim the file and emit react/jsx-dev-runtime imports.\n        enforce: 'pre' as const,\n\n        configResolved(config: { command: string; root: string }) {\n          isDev = options.dev ?? config.command === 'serve';\n          projectRoot = config.root;\n        },\n\n        async handleHotUpdate({\n          file,\n          server,\n        }: {\n          file: string;\n          server: {\n            ws: { send: (msg: unknown) => void };\n            moduleGraph: {\n              invalidateModule(\n                mod: unknown,\n                seen?: Set<unknown>,\n                timestamp?: number,\n                isHmr?: boolean,\n              ): void;\n              getModuleById?(id: string): unknown;\n              idToModuleMap?: Map<string, unknown>;\n            };\n          };\n        }) {\n          const tagName = fileToTagName.get(file) ?? cssFileToTagName.get(file);\n          if (!tagName) return;\n          // Invalidate the virtual CSS module (\\0stencil-css:...) so Vite\n          // rewrites its import URL with ?t=timestamp when serving the\n          // re-fetched TSX — prevents the browser's ESM cache serving stale CSS.\n          const virtualId = cssRealToVirtualId.get(file);\n          if (virtualId) {\n            const virtualMod =\n              server.moduleGraph.getModuleById?.(virtualId) ??\n              server.moduleGraph.idToModuleMap?.get(virtualId);\n            if (virtualMod)\n              server.moduleGraph.invalidateModule(virtualMod, new Set(), Date.now(), true);\n          }\n          // Update the docs registry and notify the client only when the CEM\n          // actually changed (new/renamed prop, type update, JSDoc edit, etc.).\n          // Pure implementation changes leave the CEM identical and fall through\n          // to normal stencil:hmr so HMR is not disrupted.\n          if (options.docs && fileToTagName.has(file)) {\n            let cemChanged = false;\n            try {\n              const prevSnapshot = JSON.stringify(docsRegistry.get(tagName));\n              const code = readFileSync(file, 'utf-8');\n              const result = await transpile(code, { file, componentExport: 'customelement' });\n              for (const item of result.data ?? []) {\n                if (!item.tagName) continue;\n                const component = cmpMetaToDocsComponent(item, file);\n                resolveImportedTypes(component, file);\n                docsRegistry.set(item.tagName, component);\n              }\n              cemChanged = JSON.stringify(docsRegistry.get(tagName)) !== prevSnapshot;\n            } catch {\n              // stale docs are acceptable on transpile error\n            }\n            if (cemChanged) {\n              const docsVirtualMod =\n                server.moduleGraph.getModuleById?.(VIRTUAL_DOCS_PREFIX) ??\n                server.moduleGraph.idToModuleMap?.get(VIRTUAL_DOCS_PREFIX);\n              if (docsVirtualMod)\n                server.moduleGraph.invalidateModule(docsVirtualMod, new Set(), Date.now(), true);\n              server.ws.send({ type: 'custom', event: 'stencil:docs-update' });\n            }\n          }\n          server.ws.send({ type: 'custom', event: 'stencil:hmr', data: { tagName } });\n          return [];\n        },\n      },\n    };\n  },\n);\n","export { unpluginStencil, getStencilCEM, STENCIL_DOCS_ID } from './plugin.js';\nexport type { StencilPluginOptions } from './options.js';\n\nimport { unpluginStencil } from './plugin.js';\n\nexport const stencilVite = unpluginStencil.vite;\nexport const stencilRollup = unpluginStencil.rollup;\nexport const stencilWebpack = unpluginStencil.webpack;\nexport const stencilEsbuild = unpluginStencil.esbuild;\nexport const stencilRspack = unpluginStencil.rspack;\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@stencil/unplugin",
+  "version": "5.0.0-alpha.16",
+  "description": "Universal bundler plugin for Stencil components (Vite, Rollup, Webpack, esbuild)",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./docs": {
+      "types": "./dist/docs.d.mts",
+      "default": "./dist/docs.mjs"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm run test:unit",
+    "test:unit": "vitest run --config vitest.config.ts",
+    "test:browser": "vitest run --config vitest.browser.config.ts",
+    "playground": "vite playground"
+  },
+  "dependencies": {
+    "@rollup/pluginutils": "^5.4.0",
+    "jiti": "^2.0.0",
+    "local-pkg": "^1.2.1",
+    "unplugin": "^3.0.0"
+  },
+  "devDependencies": {
+    "@stencil/core": "workspace:*",
+    "@types/less": "^3.0.8",
+    "@vitest/browser": "catalog:",
+    "@vitest/browser-playwright": "catalog:",
+    "less": "^4.6.7",
+    "lightningcss": "^1.32.0",
+    "postcss": "^8.5.15",
+    "postcss-load-config": "^6.0.1",
+    "sass": "^1.101.0",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vite": "^8.1.0",
+    "vitest": "catalog:"
+  },
+  "peerDependencies": {
+    "@stencil/core": "^5.0.0-0",
+    "less": "^4.0.0",
+    "lightningcss": "^1.0.0",
+    "postcss": "^8.0.0",
+    "postcss-load-config": "^4.0.0 || ^5.0.0 || ^6.0.0",
+    "sass": "^1.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "less": {
+      "optional": true
+    },
+    "lightningcss": {
+      "optional": true
+    },
+    "postcss": {
+      "optional": true
+    },
+    "postcss-load-config": {
+      "optional": true
+    },
+    "sass": {
+      "optional": true
+    }
+  }
+}