@stencil/core 4.43.5 → 5.0.0-alpha.10

package/dist/signals/index.d.ts

@@ -0,0 +1,47 @@
+import { ReadonlySignal, ReadonlySignal as ReadonlySignal$1, Signal, batch, computed, effect, signal, untracked } from "@preact/signals-core";
+//#region src/runtime/signals.d.ts
+declare const STENCIL_SIGNALS_SYMBOL: unique symbol;
+//#endregion
+//#region src/signals/index.d.ts
+/**
+ * Returns the `ReadonlySignal` backing a `@Prop` member on a Stencil element.
+ * Requires `signalBacking: true` in `stencil.config.ts`.
+ * Only `@Prop` members are exposed - `@State` is internal component state.
+ *
+ * Useful for cross-component or cross-framework reactivity without polling or events:
+ * ```ts
+ * import { getSignal, computed } from '@stencil/core/signals';
+ *
+ * const count = getSignal<number>(myEl, 'count');
+ * const doubled = computed(() => count.value * 2);
+ * ```
+ *
+ * @param elm - the Stencil host element
+ * @param prop - the `@Prop` member name
+ * @returns the `ReadonlySignal` for the prop, or `null` if not found / not signal-backed
+ */
+declare const getSignal: <T = unknown>(elm: Element, prop: string) => ReadonlySignal$1<T> | null;
+/**
+ * Marks a class method as a reactive effect. Wraps the method in `effect()` after
+ * signal initialization and registers cleanup on disconnect. Dependencies are
+ * auto-tracked - any signal read inside re-runs the method on change.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from '@stencil/core/signals';
+ *
+ * @Component({ tag: 'my-cmp' })
+ * export class MyCmp {
+ *   @State() count = 0;
+ *
+ *   @Effect()
+ *   log() {
+ *     console.log(this.count); // re-runs whenever count changes
+ *   }
+ * }
+ * ```
+ * @returns a MethodDecorator that registers the method as a reactive effect
+ */
+declare function Effect(): MethodDecorator;
+//#endregion
+export { Effect, type ReadonlySignal, STENCIL_SIGNALS_SYMBOL, type Signal, batch, computed, effect, getSignal, signal, untracked };

package/dist/signals/index.js

@@ -0,0 +1,199 @@
+import { batch, computed, effect, signal, untracked } from "@preact/signals-core";
+//#region src/app-data/index.ts
+/**
+* A collection of default build flags for a Stencil project.
+*
+* This collection can be found throughout the Stencil codebase, often imported from the `virtual:app-data` module like so:
+* ```ts
+* import { BUILD } from 'virtual:app-data';
+* ```
+* and is used to determine if a portion of the output of a Stencil _project_'s compilation step can be eliminated.
+*
+* e.g. When `BUILD.allRenderFn` evaluates to `false`, the compiler will eliminate conditional statements like:
+* ```ts
+* if (BUILD.allRenderFn) {
+*   // some code that will be eliminated if BUILD.allRenderFn is false
+* }
+* ```
+*
+* `virtual:app-data`, the module that `BUILD` is imported from, is an alias for `@stencil/core/app-data`, and is
+* partially referenced by {@link STENCIL_APP_DATA_ID}. The `src/compiler/bundle/app-data-plugin.ts` references
+* `STENCIL_APP_DATA_ID` uses it to replace these defaults with {@link BuildConditionals} that are derived from a
+* Stencil project's contents (i.e. metadata from the components). This replacement happens at a Stencil project's
+* compile time. Such code can be found at `src/compiler/app-core/app-data.ts`.
+*/
+const BUILD = {
+	allRenderFn: false,
+	element: true,
+	event: true,
+	hasRenderFn: true,
+	hostListener: true,
+	hostListenerTargetWindow: true,
+	hostListenerTargetDocument: true,
+	hostListenerTargetBody: true,
+	hostListenerTarget: true,
+	member: true,
+	method: true,
+	mode: true,
+	observeAttribute: true,
+	prop: true,
+	propMutable: true,
+	reflect: true,
+	scoped: true,
+	shadowDom: true,
+	shadowModeClosed: false,
+	slot: true,
+	cssAnnotations: true,
+	state: true,
+	style: true,
+	formAssociated: true,
+	svg: true,
+	updatable: true,
+	vdomAttribute: true,
+	vdomXlink: true,
+	vdomClass: true,
+	vdomFunctional: true,
+	vdomKey: true,
+	vdomListener: true,
+	vdomRef: true,
+	vdomPropOrAttr: true,
+	vdomRender: true,
+	vdomStyle: true,
+	vdomText: true,
+	propChangeCallback: true,
+	taskQueue: true,
+	lifecycle: true,
+	serializer: true,
+	deserializer: true,
+	patchAll: true,
+	patchChildren: true,
+	patchClone: true,
+	patchInsert: true,
+	hotModuleReplacement: false,
+	isDebug: false,
+	isDev: false,
+	isTesting: false,
+	hydrateServerSide: false,
+	hydrateClientSide: false,
+	lifecycleDOMEvents: false,
+	lazyLoad: false,
+	profile: false,
+	slotRelocation: true,
+	lightDomPatches: true,
+	slotChildNodes: true,
+	slotCloneNode: true,
+	slotDomMutations: true,
+	slotTextContent: true,
+	hydratedAttribute: false,
+	hydratedClass: true,
+	invisiblePrehydration: true,
+	staticHydrationStyles: false,
+	propBoolean: true,
+	propNumber: true,
+	propString: true,
+	constructableCSS: true,
+	devTools: false,
+	shadowDelegatesFocus: true,
+	shadowSlotAssignmentManual: false,
+	initializeNextTick: false,
+	asyncLoading: true,
+	asyncQueue: false
+};
+BUILD.isDev, BUILD.isTesting;
+const MEMBER_FLAGS = {
+	String: 1,
+	Number: 2,
+	Boolean: 4,
+	Any: 8,
+	Unknown: 16,
+	State: 32,
+	Method: 64,
+	Event: 128,
+	Element: 256,
+	ReflectAttr: 512,
+	Mutable: 1024,
+	Getter: 2048,
+	Setter: 4096,
+	Prop: 31,
+	HasAttribute: 31,
+	PropLike: 63
+};
+//#endregion
+//#region src/client/client-host-ref.ts
+/**
+* Given a {@link d.RuntimeRef} retrieve the corresponding {@link d.HostRef}
+*
+* @param ref the runtime ref of interest
+* @returns the Host reference (if found) or undefined
+*/
+const getHostRef = (ref) => {
+	if (ref.__s_ghr) return ref.__s_ghr();
+};
+//#endregion
+//#region src/client/client-log.ts
+const STENCIL_DEV_MODE = BUILD.isTesting ? ["STENCIL:"] : ["%cstencil", "color: white;background:#4c47ff;font-weight: bold; font-size:10px; padding:2px 6px; border-radius: 5px"];
+const consoleDevWarn = (...m) => console.warn(...STENCIL_DEV_MODE, ...m);
+/*!__STENCIL_STATIC_IMPORT_SWITCH__*/
+(typeof window !== "undefined" ? window : {}).HTMLElement;
+BUILD.constructableCSS;
+//#endregion
+//#region src/runtime/signals.ts
+const STENCIL_SIGNALS_SYMBOL = Symbol.for("stencil.signals");
+BUILD.lazyLoad || globalThis.HTMLElement;
+//#endregion
+//#region src/signals/index.ts
+/**
+* Returns the `ReadonlySignal` backing a `@Prop` member on a Stencil element.
+* Requires `signalBacking: true` in `stencil.config.ts`.
+* Only `@Prop` members are exposed - `@State` is internal component state.
+*
+* Useful for cross-component or cross-framework reactivity without polling or events:
+* ```ts
+* import { getSignal, computed } from '@stencil/core/signals';
+*
+* const count = getSignal<number>(myEl, 'count');
+* const doubled = computed(() => count.value * 2);
+* ```
+*
+* @param elm - the Stencil host element
+* @param prop - the `@Prop` member name
+* @returns the `ReadonlySignal` for the prop, or `null` if not found / not signal-backed
+*/
+const getSignal = (elm, prop) => {
+	const hostRef = getHostRef(elm);
+	if (!hostRef?.$signalValues$) {
+		if (BUILD.isDev) consoleDevWarn(`getSignal('${prop}'): element <${elm.tagName.toLowerCase()}> is not signal-backed. Ensure signalBacking is true in stencil.config.ts.`);
+		return null;
+	}
+	if (!((hostRef.$cmpMeta$?.$members$?.[prop]?.[0] ?? 0) & MEMBER_FLAGS.Prop)) return null;
+	return hostRef.$signalValues$.get(prop) ?? null;
+};
+/**
+* Marks a class method as a reactive effect. Wraps the method in `effect()` after
+* signal initialization and registers cleanup on disconnect. Dependencies are
+* auto-tracked - any signal read inside re-runs the method on change.
+*
+* @example
+* ```ts
+* import { Effect } from '@stencil/core/signals';
+*
+* @Component({ tag: 'my-cmp' })
+* export class MyCmp {
+*   @State() count = 0;
+*
+*   @Effect()
+*   log() {
+*     console.log(this.count); // re-runs whenever count changes
+*   }
+* }
+* ```
+* @returns a MethodDecorator that registers the method as a reactive effect
+*/
+function Effect() {
+	return (target, propertyKey) => {
+		const proto = target;
+		(proto.__stencilEffects ??= []).push(propertyKey);
+	};
+}
+//#endregion
+export { Effect, STENCIL_SIGNALS_SYMBOL, batch, computed, effect, getSignal, signal, untracked };

package/dist/sys/node/index.d.mts

@@ -0,0 +1,32 @@
+import { ei as Logger, vr as CompilerSystem } from "../../index-vY35H18z.mjs";
+
+//#region src/sys/node/logger/index.d.ts
+/**
+ * Create a logger to run in a Node environment
+ *
+ * @returns the created logger
+ */
+declare const createNodeLogger: () => Logger;
+//#endregion
+//#region src/sys/node/node-setup-process.d.ts
+declare function setupNodeProcess(c: {
+  process: any;
+  logger: Logger;
+}): void;
+//#endregion
+//#region src/sys/node/node-sys.d.ts
+/**
+ * Create a node.js-specific {@link CompilerSystem} to be used when Stencil is
+ * run from the CLI or via the public API in a node context.
+ *
+ * This takes an optional param supplying a `process` object to be used.
+ *
+ * @param c an optional object wrapping `process` and `logger` objects
+ * @returns a node.js `CompilerSystem` object
+ */
+declare function createNodeSys(c?: {
+  process?: any;
+  logger?: Logger;
+}): CompilerSystem;
+//#endregion
+export { createNodeLogger, createNodeSys, setupNodeProcess };

package/dist/sys/node/index.mjs

@@ -0,0 +1,2 @@
+import { n as setupNodeProcess, r as createNodeLogger, t as createNodeSys } from "../../node--akYC-sG.mjs";
+export { createNodeLogger, createNodeSys, setupNodeProcess };

package/dist/sys/node/worker.d.mts

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

package/dist/sys/node/worker.mjs

@@ -0,0 +1,48 @@
+import { l as createWorkerMessageHandler } from "../../compiler-lTINDSgw.mjs";
+import { t as createNodeSys } from "../../node--akYC-sG.mjs";
+//#region src/sys/node/node-worker-thread.ts
+/**
+* Initialize a worker thread, setting up various machinery for managing
+* communication between the child process (worker) and the main thread.
+*
+* @param process a NodeJS process
+* @param msgHandler a worker message handler, which processes incoming
+* messages
+*/
+const initNodeWorkerThread = (process, msgHandler) => {
+	const sendHandle = (err) => {
+		if (err && err.code === "ERR_IPC_CHANNEL_CLOSED") process.exit(0);
+	};
+	const errorHandler = (stencilMsgId, err) => {
+		const errMsgBackToMain = {
+			stencilId: stencilMsgId,
+			stencilRtnValue: null,
+			stencilRtnError: "Error"
+		};
+		if (typeof err === "string") errMsgBackToMain.stencilRtnError += ": " + err;
+		else if (err) {
+			if (err.stack) errMsgBackToMain.stencilRtnError += ": " + err.stack;
+			else if (err.message) errMsgBackToMain.stencilRtnError += ":" + err.message;
+		}
+		process.send(errMsgBackToMain, sendHandle);
+	};
+	process.on("message", async (msgToWorker) => {
+		if (msgToWorker && typeof msgToWorker.stencilId === "number") try {
+			const msgFromWorker = {
+				stencilId: msgToWorker.stencilId,
+				stencilRtnValue: await msgHandler(msgToWorker),
+				stencilRtnError: null
+			};
+			process.send(msgFromWorker, sendHandle);
+		} catch (e) {
+			errorHandler(msgToWorker.stencilId, e);
+		}
+	});
+	process.on(`unhandledRejection`, (e) => {
+		errorHandler(-1, e);
+	});
+};
+const msgHandler = createWorkerMessageHandler(createNodeSys({ process }));
+initNodeWorkerThread(process, msgHandler);
+//#endregion
+export {};

package/dist/testing/index.d.mts

@@ -0,0 +1,303 @@
+import { $r as LogLevel, B as ComponentCompilerMeta, Br as Diagnostic, Dt as HostRef, E as CompilerCtx, Et as HostElement, Nt as Module, Rt as NewSpecPageOptions, Zn as Compiler, Zr as LoadConfigInit, a as BuildCtx, aa as ValidatedConfig, cn as RuntimeRef, ei as Logger, fa as RafCallback, ha as UserBuildConditionals, ia as UnvalidatedConfig, kr as Config, mt as ComponentRuntimeMeta, ni as LoggerTimeSpan, pn as SpecPage, ua as ErrorHandler, vr as CompilerSystem } from "../index-vY35H18z.mjs";
+import { a as h, b as Env, d as getMode, g as getElement, h as createEvent, i as Host, m as Fragment, o as forceUpdate, p as Mixin, s as getRenderingRef, v as getAssetPath, y as setAssetPath } from "../index-BvkyxSY6.mjs";
+import { Mock } from "vitest";
+
+//#region src/testing/testing-logger.d.ts
+declare class TestingLogger implements Logger {
+  private isEnabled;
+  enable(): void;
+  setLevel(_level: LogLevel): void;
+  getLevel(): LogLevel;
+  enableColors(_useColors: boolean): void;
+  emoji(_: string): string;
+  info(...msg: any[]): void;
+  warn(...msg: any[]): void;
+  error(...msg: any[]): void;
+  debug(...msg: any[]): void;
+  color(_msg: string, _color: 'red' | 'green' | 'yellow' | 'blue' | 'magenta' | 'cyan' | 'gray'): void;
+  red(msg: string): string;
+  green(msg: string): string;
+  yellow(msg: string): string;
+  blue(msg: string): string;
+  magenta(msg: string): string;
+  cyan(msg: string): string;
+  gray(msg: string): string;
+  bold(msg: string): string;
+  dim(msg: string): string;
+  bgRed(msg: string): string;
+  createTimeSpan(_startMsg: string, _debug?: boolean): LoggerTimeSpan;
+  printDiagnostics(_diagnostics: Diagnostic[]): void;
+}
+//#endregion
+//#region src/testing/testing-sys.d.ts
+interface TestingSystem extends CompilerSystem {
+  diskReads: number;
+  diskWrites: number;
+}
+declare const createTestingSystem: () => TestingSystem;
+//#endregion
+//#region src/testing/mocks.d.ts
+/**
+ * Generates a stub {@link d.ComponentCompilerMeta}. This function uses sensible defaults for the initial stub. However,
+ * any field in the object may be overridden via the `overrides` argument.
+ * @param overrides a partial implementation of `ComponentCompilerMeta`. Any provided fields will override the
+ * defaults provided by this function.
+ * @returns the stubbed `ComponentCompilerMeta`
+ */
+declare const mockComponentMeta: (overrides?: Partial<ComponentCompilerMeta>) => ComponentCompilerMeta;
+/**
+ * Creates a mock instance of an internal, validated Stencil configuration object
+ * the caller
+ * @param overrides a partial implementation of `ValidatedConfig`. Any provided fields will override the defaults
+ * provided by this function.
+ * @returns the mock Stencil configuration
+ */
+declare function mockValidatedConfig(overrides?: Partial<ValidatedConfig>): ValidatedConfig;
+/**
+ * Creates a mock instance of a Stencil configuration entity. The mocked configuration has no guarantees around the
+ * types/validity of its data.
+ * @param overrides a partial implementation of `UnvalidatedConfig`. Any provided fields will override the defaults
+ * provided by this function.
+ * @returns the mock Stencil configuration
+ */
+declare function mockConfig(overrides?: Partial<UnvalidatedConfig>): UnvalidatedConfig;
+/**
+ * Creates a configuration object used to bootstrap a Stencil task invocation
+ *
+ * Several fields are intentionally undefined for this entity. While it would be trivial to stub them out, this mock
+ * generation function operates under the assumption that entities like loggers and compiler system abstractions will
+ * be shared by multiple entities in a test suite, who should provide those entities to this function
+ *
+ * @param overrides the properties on the default entity to manually override
+ * @returns the default configuration initialization object, with any overrides applied
+ */
+declare const mockLoadConfigInit: (overrides?: Partial<LoadConfigInit>) => LoadConfigInit;
+declare function mockCompilerCtx(config?: ValidatedConfig): CompilerCtx;
+declare function mockBuildCtx(config?: ValidatedConfig, compilerCtx?: CompilerCtx): BuildCtx;
+declare function mockLogger(): TestingLogger;
+/**
+ * Create a {@link d.CompilerSystem} entity for testing the compiler.
+ *
+ * This function acts as a thin wrapper around a {@link TestingSystem} entity creation. It exists to provide a logical
+ * place in the codebase where we might expect Stencil engineers to reach for when attempting to mock a
+ * {@link d.CompilerSystem} base type. Should there prove to be usage of both this function and the one it wraps,
+ * reconsider if this wrapper is necessary.
+ *
+ * @returns a System instance for testing purposes.
+ */
+declare function mockCompilerSystem(): TestingSystem;
+declare function mockDocument(html?: string | null): Document;
+declare function mockWindow(html?: string): Window;
+/**
+ * This gives you a mock Module, an interface which is the internal compiler
+ * representation of a module. It includes a bunch of information necessary for
+ * compilation, this mock basically sets sane defaults for all those values.
+ *
+ * @param mod is an override module that you can supply to set particular values
+ * @returns a module object ready to use in tests!
+ */
+declare const mockModule: (mod?: Partial<Module>) => Module;
+//#endregion
+//#region src/testing/create-test-compiler.d.ts
+/**
+ * Options for creating a test compiler
+ */
+interface CreateTestCompilerOptions {
+  /**
+   * Additional configuration overrides for the test compiler
+   */
+  config?: Partial<Config>;
+  /**
+   * Path to a tsconfig.json file. Defaults to {@link TESTING_TSCONFIG}.
+   * To add custom options, create a file that `extends` the base fixture:
+   * `{ "extends": "./path/to/tsconfig.testing.json", "compilerOptions": { ... } }`
+   */
+  tsconfig?: string;
+  /**
+   * Pre-validated compiler setup from {@link prepareTestCompiler}. When
+   * provided, the expensive `loadConfig` step is skipped and a fresh compiler
+   * is created directly from the cached validated config.
+   */
+  setup?: PreparedTestCompiler;
+}
+/**
+ * Result of creating a test compiler
+ */
+interface TestCompilerResult {
+  /**
+   * The compiler instance ready for testing
+   */
+  compiler: Compiler;
+  /**
+   * The validated configuration used to create the compiler
+   */
+  config: ValidatedConfig;
+  /**
+   * The compiler system instance
+   */
+  sys: CompilerSystem;
+}
+/**
+ * A pre-validated compiler configuration that can be reused across multiple
+ * `createTestCompiler` calls within the same test suite to avoid repeating
+ * the expensive `loadConfig` step.
+ *
+ * Obtain via {@link prepareTestCompiler} in a `beforeAll` block, then pass as
+ * `options.setup` to {@link createTestCompiler} in each `beforeEach`.
+ */
+interface PreparedTestCompiler {
+  /** @internal */
+  _validatedConfig: ValidatedConfig;
+  /** @internal */
+  _tsconfigPath: string;
+}
+/**
+ * Runs the expensive one-time setup for a test compiler suite: patching the
+ * sys, reading and validating the tsconfig. Use this in a `beforeAll` block
+ * when a describe block contains multiple tests that each need a fresh
+ * compiler, to avoid repeating `loadConfig` on every test.
+ *
+ * @param options - Configuration options for preparing the test compiler
+ * @returns A {@link PreparedTestCompiler} that can be passed to {@link createTestCompiler}
+ *
+ * @example
+ * ```ts
+ * let setup: PreparedTestCompiler;
+ * beforeAll(async () => { setup = await prepareTestCompiler(); });
+ * beforeEach(async () => {
+ *   const { compiler } = await createTestCompiler({ setup });
+ * });
+ * ```
+ */
+declare const prepareTestCompiler: (options?: Omit<CreateTestCompilerOptions, "setup">) => Promise<PreparedTestCompiler>;
+/**
+ * Creates a test compiler instance with a hybrid filesystem (reads from disk, writes to memory).
+ * This utility handles the common setup pattern for compiler tests.
+ *
+ * When multiple tests in the same suite need independent compiler instances,
+ * pass a {@link PreparedTestCompiler} from {@link prepareTestCompiler} as
+ * `options.setup` to skip the expensive `loadConfig` step on each test.
+ *
+ * @param options - Configuration options for the test compiler
+ * @returns An object with the compiler, validated config, and system instance
+ *
+ * @example
+ * ```ts
+ * const { compiler, config } = await createTestCompiler({
+ *   config: { minifyCss: true }
+ * });
+ * await compiler.fs.writeFile('/src/index.html', '<cmp-a></cmp-a>');
+ * const result = await compiler.build();
+ * ```
+ */
+declare const createTestCompiler: (options?: CreateTestCompilerOptions) => Promise<TestCompilerResult>;
+//#endregion
+//#region src/testing/spec-page.d.ts
+/**
+ * Creates a new spec page for unit testing
+ * @param opts the options to apply to the spec page that influence its configuration and operation
+ * @returns the created spec page
+ */
+declare function newSpecPage(opts: NewSpecPageOptions): Promise<SpecPage>;
+//#endregion
+//#region src/testing/testing-utils.d.ts
+/**
+ * Shuffle an array using Fisher-Yates algorithm
+ * http://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+ *
+ * @param array - the array to shuffle
+ * @returns the shuffled array
+ */
+declare function shuffleArray(array: any[]): any[];
+/**
+ * Utility for silencing `console` functions in tests.
+ *
+ * When this function is first called it grabs a reference to the `log`,
+ * `error`, and `warn` functions on `console` and then returns a per-test setup
+ * function which sets up a fresh set of mocks (via `jest.fn()`) and then
+ * assigns them to each of these functions. This setup function will return a
+ * reference to each of the three mock functions so tests can make assertions
+ * about their calls and so on.
+ *
+ * Because references to the original `.log`, `.error`, and `.warn` functions
+ * exist in closure within the function, it can use an `afterAll` call to clean
+ * up after itself and ensure that the original implementations are restored
+ * after the test suite finishes.
+ *
+ * An example of using this to silence log statements in a single test could look
+ * like this:
+ *
+ * ```ts
+ * describe("my-test-suite", () => {
+ *   const { setupConsoleMocks, teardownConsoleMocks } = setupConsoleMocker()
+ *
+ *   it("should log a message", () => {
+ *     const { logMock } = setupConsoleMocks();
+ *     myFunctionWhichLogs(foo, bar);
+ *     expect(logMock).toBeCalledWith('my log message');
+ *     teardownConsoleMocks();
+ *   })
+ * })
+ * ```
+ *
+ * @returns a per-test mock setup function
+ */
+declare function setupConsoleMocker(): ConsoleMocker;
+interface ConsoleMocker {
+  setupConsoleMocks: () => {
+    logMock: Mock<typeof console.log>;
+    warnMock: Mock<typeof console.warn>;
+    errorMock: Mock<typeof console.error>;
+  };
+  teardownConsoleMocks: () => void;
+}
+/**
+ * the callback that `withSilentWarn` expects to receive. Basically receives a mock
+ * as its argument and returns a `Promise`, the value of which is returned by `withSilentWarn`
+ * as well.
+ */
+//#endregion
+//#region src/testing/platform/testing-build.d.ts
+declare const Build: UserBuildConditionals;
+//#endregion
+//#region src/testing/platform/testing-host-ref.d.ts
+/**
+ * Retrieve the data structure tracking the component by its runtime reference
+ * @param elm the reference to the element
+ * @returns the corresponding Stencil reference data structure, or undefined if one cannot be found
+ */
+declare const getHostRef: (elm: RuntimeRef | undefined) => HostRef | undefined;
+/**
+ * Add the provided `hostRef` instance to the global {@link hostRefs} map, using the provided `lazyInstance` as a key.
+ * @param lazyInstance a Stencil component instance
+ * @param hostRef an optional reference to Stencil's tracking data for the component. If none is provided, one will be created.
+ * @throws if the provided `lazyInstance` coerces to `null`, or if the `lazyInstance` does not have a `constructor`
+ * property
+ */
+declare const registerInstance: (lazyInstance: any, hostRef: HostRef | null | undefined) => void;
+/**
+ * Create a new {@link d.HostRef} instance to the global {@link hostRefs} map, using the provided `elm` as a key.
+ * @param elm an HTMLElement instance associated with the Stencil component
+ * @param cmpMeta the component compiler metadata associated with the component
+ */
+declare const registerHost: (elm: HostElement, cmpMeta: ComponentRuntimeMeta) => void;
+//#endregion
+//#region src/testing/platform/testing-log.d.ts
+declare const setErrorHandler: (handler: ErrorHandler | undefined) => ErrorHandler;
+//#endregion
+//#region src/testing/platform/testing-task-queue.d.ts
+/**
+ * Push a RequestAnimationFrame callback onto the {@link queuedWriteTasks} data structure
+ * @param cb the callback to push onto `queuedWriteTasks`
+ */
+declare function writeTask(cb: RafCallback): void;
+/**
+ * Push a RequestAnimationFrame callback onto the {@link queuedReadTasks} data structure
+ * @param cb the callback to push onto `queuedReadTasks`
+ */
+declare function readTask(cb: RafCallback): void;
+//#endregion
+//#region src/testing/platform/index.d.ts
+declare const setMode: (handler: (elm: any) => string | undefined | null) => void;
+//#endregion
+export { Build, type CreateTestCompilerOptions, Env, Fragment, Host, Mixin, type PreparedTestCompiler, type SpecPage, type TestCompilerResult, createEvent, createTestCompiler, createTestingSystem, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRenderingRef, h, mockBuildCtx, mockCompilerCtx, mockCompilerSystem, mockComponentMeta, mockConfig, mockDocument, mockLoadConfigInit, mockLogger, mockModule, mockValidatedConfig, mockWindow, newSpecPage, prepareTestCompiler, readTask, registerHost, registerInstance, setAssetPath, setErrorHandler, setMode, setupConsoleMocker, shuffleArray, writeTask };