@stencil/vitest 0.0.1-dev.20260109124515.90fb962

package/dist/config.d.ts

@@ -0,0 +1,73 @@
+import { type ViteUserConfig } from 'vitest/config';
+import type { Config as StencilConfig } from '@stencil/core/internal';
+/**
+ * Define a Vitest configuration for Stencil component testing
+ *
+ * Accepts standard Vitest config with optional Stencil enhancements.
+ * Automatically applies Stencil-specific defaults:
+ * - JSX configuration (h, Fragment)
+ * - Resolve aliases from Stencil config (@, @components, @utils)
+ * - Coverage configuration based on srcDir
+ * - Exclude patterns for build outputs
+ * - Auto-injects jsdom-setup for environment: 'jsdom'
+ * - Auto-injects happy-dom-setup for environment: 'happy-dom'
+ * - Custom 'stencil' environment handles its own setup
+ *
+ * @example
+ * ```ts
+ * import { defineVitestConfig } from '@stencil/vitest/config';
+ *
+ * export default defineVitestConfig({
+ *   test: {
+ *     projects: [
+ *       {
+ *         test: {
+ *           name: 'stencil',
+ *           include: ['**\/*.spec.tsx'],
+ *           environment: 'stencil',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *          // environmentOptions: {
+ *          //   stencil: {
+ *          //     domEnvironment: 'happy-dom' // 'jsdom' | 'mock-doc' (default), Make sure to install relevant packages
+ *          //   },
+ *          // },
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'jsdom',
+ *           include: ['**\/*.jsdom.spec.tsx'],
+ *           environment: 'jsdom',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'happy-dom',
+ *           include: ['**\/*.happy.spec.tsx'],
+ *           environment: 'happy-dom',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'browser',
+ *           include: ['**\/*.e2e.tsx'],
+ *           browser: {
+ *             enabled: true,
+ *             provider: 'playwright',
+ *             instances: [
+ *               { browser: 'chromium' }
+ *             ],
+ *           },
+ *         },
+ *       },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export declare function defineVitestConfig(config?: ViteUserConfig & {
+    stencilConfig?: string | StencilConfig;
+}): Promise<ViteUserConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAOlE,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,GAAE,cAAc,GAAG;IAAE,aAAa,CAAC,EAAE,MAAM,GAAG,aAAa,CAAA;CAAO,GACvE,OAAO,CAAC,cAAc,CAAC,CAqBzB"}

package/dist/config.js

@@ -0,0 +1,302 @@
+import { defineConfig } from 'vitest/config';
+import { loadStencilConfig, getStencilSrcDir, getStencilOutputDirs, getStencilResolveAliases, } from './setup/config-loader.js';
+/**
+ * Define a Vitest configuration for Stencil component testing
+ *
+ * Accepts standard Vitest config with optional Stencil enhancements.
+ * Automatically applies Stencil-specific defaults:
+ * - JSX configuration (h, Fragment)
+ * - Resolve aliases from Stencil config (@, @components, @utils)
+ * - Coverage configuration based on srcDir
+ * - Exclude patterns for build outputs
+ * - Auto-injects jsdom-setup for environment: 'jsdom'
+ * - Auto-injects happy-dom-setup for environment: 'happy-dom'
+ * - Custom 'stencil' environment handles its own setup
+ *
+ * @example
+ * ```ts
+ * import { defineVitestConfig } from '@stencil/vitest/config';
+ *
+ * export default defineVitestConfig({
+ *   test: {
+ *     projects: [
+ *       {
+ *         test: {
+ *           name: 'stencil',
+ *           include: ['**\/*.spec.tsx'],
+ *           environment: 'stencil',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *          // environmentOptions: {
+ *          //   stencil: {
+ *          //     domEnvironment: 'happy-dom' // 'jsdom' | 'mock-doc' (default), Make sure to install relevant packages
+ *          //   },
+ *          // },
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'jsdom',
+ *           include: ['**\/*.jsdom.spec.tsx'],
+ *           environment: 'jsdom',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'happy-dom',
+ *           include: ['**\/*.happy.spec.tsx'],
+ *           environment: 'happy-dom',
+ *           setupFiles: ['./vitest-setup.ts'],
+ *         },
+ *       },
+ *       {
+ *         test: {
+ *           name: 'browser',
+ *           include: ['**\/*.e2e.tsx'],
+ *           browser: {
+ *             enabled: true,
+ *             provider: 'playwright',
+ *             instances: [
+ *               { browser: 'chromium' }
+ *             ],
+ *           },
+ *         },
+ *       },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export async function defineVitestConfig(config = {}) {
+    // Load Stencil config if provided (optional)
+    let stencilConfig;
+    if (typeof config.stencilConfig === 'string') {
+        try {
+            stencilConfig = await loadStencilConfig(config.stencilConfig);
+        }
+        catch {
+            // loading is optional
+        }
+    }
+    else if (config.stencilConfig) {
+        stencilConfig = config.stencilConfig;
+    }
+    // Remove stencilConfig from the final config (destructure to exclude it)
+    const { stencilConfig: _stencilConfig, ...vitestConfig } = config;
+    // Apply Stencil-specific defaults
+    const enhancedConfig = applyStencilDefaults(vitestConfig, stencilConfig);
+    return defineConfig(enhancedConfig);
+}
+/**
+ * Generate coverage exclude patterns from test include patterns
+ */
+function generateCoverageExcludes(testIncludes, srcDir) {
+    const excludes = [];
+    for (const include of testIncludes) {
+        // Convert test include patterns to coverage exclude patterns
+        // Examples:
+        // "src/**/*.spec.{ts,tsx}" -> "src/**/*.spec.{ts,tsx}"
+        // "**/*.spec.{ts,tsx}" -> "src/**/*.spec.{ts,tsx}" (assuming srcDir is "src")
+        // "components/**/*.test.tsx" -> "src/components/**/*.test.tsx"
+        let excludePattern = include;
+        // If pattern doesn't start with srcDir, prepend it
+        if (!excludePattern.startsWith(`${srcDir}/`)) {
+            // Handle patterns that start with **/ by replacing with srcDir
+            if (excludePattern.startsWith('**/')) {
+                excludePattern = excludePattern.replace('**/', `${srcDir}/`);
+            }
+            else {
+                // For other patterns, prepend srcDir
+                excludePattern = `${srcDir}/${excludePattern}`;
+            }
+        }
+        excludes.push(excludePattern);
+    }
+    return excludes;
+}
+/**
+ * Apply Stencil-specific defaults to Vitest config
+ */
+function applyStencilDefaults(config, stencilConfig) {
+    // Start with the user's config
+    const result = { ...config };
+    // Add esbuild JSX config if not present
+    if (!result.esbuild) {
+        result.esbuild = {
+            jsxFactory: 'h',
+            jsxFragment: 'Fragment',
+        };
+    }
+    // Add resolve aliases from Stencil config if not present
+    if (!result.resolve) {
+        result.resolve = {};
+    }
+    if (!result.resolve.alias) {
+        result.resolve.alias = getStencilResolveAliases(stencilConfig);
+    }
+    else if (typeof result.resolve.alias === 'object' && !Array.isArray(result.resolve.alias)) {
+        // Merge with existing aliases, user's aliases take precedence
+        result.resolve.alias = {
+            ...getStencilResolveAliases(stencilConfig),
+            ...result.resolve.alias,
+        };
+    }
+    // Configure Vite server to watch Stencil output directories
+    // This allows Vitest to automatically re-run tests when Stencil rebuilds components
+    if (!result.server) {
+        result.server = {};
+    }
+    if (!result.server.watch) {
+        result.server.watch = {};
+    }
+    // Ensure test config exists
+    if (!result.test) {
+        result.test = {};
+    }
+    // Enable forceRerunTriggers to watch output directories
+    // This ensures Vitest re-runs tests when Stencil rebuilds components
+    const outputDirs = getStencilOutputDirs(stencilConfig);
+    if (!result.test.forceRerunTriggers) {
+        result.test.forceRerunTriggers = [];
+    }
+    // Add output directories to force rerun triggers
+    const existingTriggers = Array.isArray(result.test.forceRerunTriggers)
+        ? result.test.forceRerunTriggers
+        : [result.test.forceRerunTriggers];
+    const outputDirTriggers = outputDirs.map((dir) => `**/${dir}/**`);
+    result.test.forceRerunTriggers = [...new Set([...existingTriggers, ...outputDirTriggers])];
+    // Add globals if not set
+    if (result.test.globals === undefined) {
+        result.test.globals = true;
+    }
+    // Add coverage config at root level if not present
+    // This applies to all projects in multi-project mode
+    if (!result.test.coverage) {
+        const srcDir = getStencilSrcDir(stencilConfig);
+        const outputDirs = getStencilOutputDirs(stencilConfig);
+        // Collect all test include patterns from projects
+        const testIncludes = [];
+        if (result.test.projects) {
+            // Multi-project mode
+            for (const project of result.test.projects) {
+                if (project.test?.include) {
+                    const includes = Array.isArray(project.test.include) ? project.test.include : [project.test.include];
+                    testIncludes.push(...includes);
+                }
+            }
+        }
+        else if (result.test.include) {
+            // Single project mode
+            const includes = Array.isArray(result.test.include) ? result.test.include : [result.test.include];
+            testIncludes.push(...includes);
+        }
+        // Generate coverage excludes from test includes
+        const coverageExcludes = testIncludes.length > 0
+            ? generateCoverageExcludes(testIncludes, srcDir)
+            : [`${srcDir}/**/*.spec.{ts,tsx}`, `${srcDir}/**/*.e2e.{ts,tsx}`, `${srcDir}/**/*.test.{ts,tsx}`];
+        result.test.coverage = {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: [`${srcDir}/**/*.{ts,tsx}`],
+            exclude: [...coverageExcludes, ...outputDirs.map((dir) => `${dir}/**`)],
+        };
+    }
+    // If there are projects, enhance each one
+    if (result.test.projects) {
+        result.test.projects = result.test.projects.map((project) => enhanceProject(project, stencilConfig));
+    }
+    else {
+        // Single project mode - enhance the test config directly
+        result.test = enhanceTestConfig(result.test, stencilConfig);
+    }
+    if (result.test.onConsoleLog === undefined) {
+        result.test.onConsoleLog = (log) => {
+            if (log?.includes('Running in development mode.'))
+                return false;
+            return true;
+        };
+    }
+    return result;
+}
+/**
+ * Enhance test config with Stencil defaults
+ */
+function enhanceTestConfig(testConfig, stencilConfig) {
+    const enhanced = { ...testConfig };
+    // Get output directories from Stencil config
+    const outputDirs = getStencilOutputDirs(stencilConfig);
+    const defaultExcludes = ['**/node_modules/**', ...outputDirs.map((dir) => `**/${dir}/**`)];
+    // Add default excludes if not present
+    if (!enhanced.exclude) {
+        enhanced.exclude = defaultExcludes;
+    }
+    else {
+        // Merge with existing excludes
+        const existingExcludes = Array.isArray(enhanced.exclude) ? enhanced.exclude : [enhanced.exclude];
+        enhanced.exclude = [
+            ...defaultExcludes,
+            ...existingExcludes.filter((pattern) => !defaultExcludes.includes(pattern)),
+        ];
+    }
+    // Add coverage config based on Stencil srcDir if not present
+    if (!enhanced.coverage) {
+        const srcDir = getStencilSrcDir(stencilConfig);
+        enhanced.coverage = {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html'],
+            include: [`${srcDir}/**/*.{ts,tsx}`],
+            exclude: [
+                `${srcDir}/**/*.spec.{ts,tsx}`,
+                `${srcDir}/**/*.e2e.{ts,tsx}`,
+                `${srcDir}/**/*.test.{ts,tsx}`,
+                ...outputDirs.map((dir) => `${dir}/**`),
+            ],
+        };
+    }
+    return enhanced;
+}
+/**
+ * Enhance a single project with Stencil defaults
+ */
+function enhanceProject(project, stencilConfig) {
+    const enhanced = { ...project };
+    // Get output directories from Stencil config
+    const outputDirs = getStencilOutputDirs(stencilConfig);
+    const defaultExcludes = ['**/node_modules/**', ...outputDirs.map((dir) => `**/${dir}/**`)];
+    // Merge default excludes with user-provided excludes
+    if (enhanced.test) {
+        if (!enhanced.test.exclude) {
+            enhanced.test.exclude = defaultExcludes;
+        }
+        else {
+            // Merge defaults with existing excludes, avoiding duplicates
+            const existingExcludes = Array.isArray(enhanced.test.exclude) ? enhanced.test.exclude : [enhanced.test.exclude];
+            enhanced.test.exclude = [
+                ...defaultExcludes,
+                ...existingExcludes.filter((pattern) => !defaultExcludes.includes(pattern)),
+            ];
+        }
+        // Auto-inject setup files based on environment
+        const setupFiles = enhanced.test.setupFiles || [];
+        const setupFilesArray = Array.isArray(setupFiles) ? setupFiles : [setupFiles];
+        const environment = enhanced.test.environment?.toLowerCase();
+        // Auto-inject setup files based on environment type
+        // This provides automatic polyfills based on the environment being used
+        // Auto-inject jsdom-setup for jsdom environment
+        if (environment === 'jsdom') {
+            if (!setupFilesArray.includes('@stencil/vitest/jsdom-setup')) {
+                enhanced.test.setupFiles = ['@stencil/vitest/jsdom-setup', ...setupFilesArray];
+            }
+        }
+        // Auto-inject happy-dom-setup for happy-dom environment
+        if (environment === 'happy-dom') {
+            if (!setupFilesArray.includes('@stencil/vitest/happy-dom-setup')) {
+                enhanced.test.setupFiles = ['@stencil/vitest/happy-dom-setup', ...setupFilesArray];
+            }
+        }
+        // Note: The 'stencil' custom environment handles its own setup internally
+        // and doesn't need auto-injection
+        // Note: coverage config is applied at the root test level, not per-project
+    }
+    return enhanced;
+}

package/dist/environments/env/happy-dom.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentStencil } from '../types.js';
+declare const _default: EnvironmentStencil;
+export default _default;
+//# sourceMappingURL=happy-dom.d.ts.map

package/dist/environments/env/happy-dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"happy-dom.d.ts","sourceRoot":"","sources":["../../../src/environments/env/happy-dom.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;wBAEtC,kBAAkB;AAAlC,wBAgBE"}

package/dist/environments/env/happy-dom.js

@@ -0,0 +1,15 @@
+import { importModule } from 'local-pkg';
+export default (async function (global, options) {
+    const { Window, GlobalWindow } = (await importModule('happy-dom'));
+    const happyDomOptions = {
+        url: 'http://localhost:3000',
+        ...options.happyDom,
+    };
+    const window = new (GlobalWindow || Window)(happyDomOptions);
+    return {
+        window,
+        teardown() {
+            window.happyDOM.abort();
+        },
+    };
+});

package/dist/environments/env/jsdom.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentStencil } from '../types.js';
+declare const _default: EnvironmentStencil;
+export default _default;
+//# sourceMappingURL=jsdom.d.ts.map

package/dist/environments/env/jsdom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdom.d.ts","sourceRoot":"","sources":["../../../src/environments/env/jsdom.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;wBAGtC,kBAAkB;AAAlC,wBAoCE"}

package/dist/environments/env/jsdom.js

@@ -0,0 +1,32 @@
+import { importModule } from 'local-pkg';
+import { applyJsdomPolyfills } from '../../setup/jsdom-setup.js';
+export default (async function (global, options) {
+    const { JSDOM, ResourceLoader, VirtualConsole, CookieJar } = (await importModule('jsdom'));
+    const jsdomOptions = {
+        html: '<!DOCTYPE html>',
+        url: 'http://localhost:3000',
+        contentType: 'text/html',
+        pretendToBeVisual: true,
+        includeNodeLocations: false,
+        runScripts: 'dangerously',
+        console: false,
+        cookieJar: false,
+        ...options.jsdom,
+    };
+    const virtualConsole = jsdomOptions.console && global.console ? new VirtualConsole().sendTo(global.console) : undefined;
+    const window = new JSDOM(jsdomOptions.html, {
+        ...jsdomOptions,
+        resources: jsdomOptions.resources ??
+            (jsdomOptions.userAgent ? new ResourceLoader({ userAgent: jsdomOptions.userAgent }) : undefined),
+        virtualConsole,
+        cookieJar: jsdomOptions.cookieJar ? new CookieJar() : undefined,
+    }).window;
+    // Apply all polyfills using shared logic
+    applyJsdomPolyfills(window);
+    return {
+        window,
+        teardown() {
+            window.close();
+        },
+    };
+});

package/dist/environments/env/mock-doc.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentStencil } from '../types.js';
+declare const _default: EnvironmentStencil;
+export default _default;
+//# sourceMappingURL=mock-doc.d.ts.map

package/dist/environments/env/mock-doc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-doc.d.ts","sourceRoot":"","sources":["../../../src/environments/env/mock-doc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;wBAGtC,kBAAkB;AAAlC,wBAaE"}

package/dist/environments/env/mock-doc.js

@@ -0,0 +1,14 @@
+import { applyMockDocPolyfills } from '../../setup/mock-doc-setup.js';
+export default (async function (_global, _options) {
+    const mockDoc = await import('@stencil/core/mock-doc');
+    const win = new mockDoc.MockWindow('http://localhost:3000/');
+    applyMockDocPolyfills(win);
+    return {
+        window: win,
+        teardown() {
+            if (typeof mockDoc.teardownGlobal === 'function') {
+                mockDoc.teardownGlobal(win);
+            }
+        },
+    };
+});

package/dist/environments/stencil.d.ts

@@ -0,0 +1,28 @@
+import type { Environment } from 'vitest/environments';
+export interface StencilEnvironmentOptions {
+    /**
+     * The DOM environment to use for testing
+     * @default 'mock-doc'
+     */
+    domEnvironment?: 'mock-doc' | 'happy-dom' | 'jsdom';
+}
+/**
+ * Custom Vitest environment for Stencil component testing
+ *
+ * Usage in vitest.config.ts:
+ * ```ts
+ * export default defineConfig({
+ *   test: {
+ *     environment: 'stencil',
+ *     environmentOptions: {
+ *       stencil: {
+ *         domEnvironment: 'mock-doc' // or 'happy-dom' or 'jsdom'
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare const _default: Environment;
+export default _default;
+//# sourceMappingURL=stencil.d.ts.map

package/dist/environments/stencil.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stencil.d.ts","sourceRoot":"","sources":["../../src/environments/stencil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAOvD,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,cAAc,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,OAAO,CAAC;CACrD;AAQD;;;;;;;;;;;;;;;;GAgBG;wBACa,WAAW;AAA3B,wBAqDE"}

package/dist/environments/stencil.js

@@ -0,0 +1,71 @@
+import { populateGlobal } from 'vitest/environments';
+import happyDom from './env/happy-dom.js';
+import jsdom from './env/jsdom.js';
+import mockDoc from './env/mock-doc.js';
+const environmentMap = {
+    'happy-dom': happyDom,
+    jsdom: jsdom,
+    'mock-doc': mockDoc,
+};
+/**
+ * Custom Vitest environment for Stencil component testing
+ *
+ * Usage in vitest.config.ts:
+ * ```ts
+ * export default defineConfig({
+ *   test: {
+ *     environment: 'stencil',
+ *     environmentOptions: {
+ *       stencil: {
+ *         domEnvironment: 'mock-doc' // or 'happy-dom' or 'jsdom'
+ *       }
+ *     }
+ *   }
+ * })
+ * ```
+ */
+export default {
+    name: 'stencil',
+    viteEnvironment: 'ssr',
+    async setup(global, options) {
+        const { stencil = {} } = options;
+        const domEnvironment = stencil.domEnvironment || 'mock-doc';
+        const environment = environmentMap[domEnvironment] || environmentMap['mock-doc'];
+        if (!environment) {
+            throw new Error(`Unknown domEnvironment: ${domEnvironment}. Must be 'mock-doc', 'happy-dom', or 'jsdom'`);
+        }
+        // Setup the environment and get the window
+        const { window: win, teardown: envTeardown } = await environment(global, options);
+        // Stub MessageEvent on global before populateGlobal to prevent Node's undici from loading
+        // This prevents "Class extends value undefined" errors from undici's WebSocket implementation
+        if (!global.MessageEvent && win.MessageEvent) {
+            Object.defineProperty(global, 'MessageEvent', {
+                value: win.MessageEvent,
+                writable: true,
+                configurable: true,
+            });
+        }
+        // Set NODE_ENV to test if not already set
+        if (!win.process?.env) {
+            win.process = { env: {} };
+        }
+        if (!win.process.env.NODE_ENV) {
+            win.process.env.NODE_ENV = 'test';
+        }
+        // Populate global with window properties
+        const { keys, originals } = populateGlobal(global, win, {
+            bindFunctions: true,
+        });
+        return {
+            teardown(global) {
+                // Teardown the environment first (e.g., window.close())
+                // This needs to happen while globals are still populated
+                // because disconnectedCallback may use RAF and other polyfills
+                envTeardown();
+                // Then clean up populated globals
+                keys.forEach((key) => delete global[key]);
+                originals.forEach((v, k) => (global[k] = v));
+            },
+        };
+    },
+};

package/dist/environments/types.d.ts

@@ -0,0 +1,6 @@
+export interface EnvironmentReturn {
+    window: Window & typeof globalThis;
+    teardown: () => void;
+}
+export type EnvironmentStencil = (global: typeof globalThis, options: any) => Promise<EnvironmentReturn>;
+//# sourceMappingURL=types.d.ts.map

package/dist/environments/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/environments/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,GAAG,OAAO,UAAU,CAAC;IACnC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE,OAAO,UAAU,EAAE,OAAO,EAAE,GAAG,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/environments/types.js

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

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import './testing/matchers.js';
+import './testing/snapshot-serializer.js';
+export { h } from '@stencil/core';
+export { render } from './testing/render.js';
+export type { RenderOptions, RenderResult } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,uBAAuB,CAAC;AAC/B,OAAO,kCAAkC,CAAC;AAE1C,OAAO,EAAE,CAAC,EAAE,MAAM,eAAe,CAAC;AAClC,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAC7C,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+// install custom matchers and snapshot serializer
+import './testing/matchers.js';
+import './testing/snapshot-serializer.js';
+export { h } from '@stencil/core';
+export { render } from './testing/render.js';

package/dist/setup/config-loader.d.ts

@@ -0,0 +1,19 @@
+import type { Config as StencilConfig } from '@stencil/core/internal';
+/**
+ * Load Stencil configuration from a file path
+ * Uses jiti to handle TypeScript files in Node.js
+ */
+export declare function loadStencilConfig(configPath: string): Promise<StencilConfig | undefined>;
+/**
+ * Get the source directory from Stencil config
+ */
+export declare function getStencilSrcDir(config?: StencilConfig): string;
+/**
+ * Get all output directories from Stencil config for exclusion
+ */
+export declare function getStencilOutputDirs(config?: StencilConfig): string[];
+/**
+ * Create resolve aliases from Stencil config
+ */
+export declare function getStencilResolveAliases(config?: StencilConfig): Record<string, string>;
+//# sourceMappingURL=config-loader.d.ts.map

package/dist/setup/config-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.ts","sourceRoot":"","sources":["../../src/setup/config-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAItE;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,GAAG,SAAS,CAAC,CAsB9F;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,CAE/D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,EAAE,CAyCrE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBvF"}