@stencil/core 5.0.0-alpha.3 → 5.0.0-alpha.31

package/dist/{index-CyrGY82h.d.ts → index-D2PAsXxx.d.ts}

@@ -1,3 +1,5 @@
+import "rolldown";
+import "typescript";
 //#region src/declarations/stencil-public-runtime.d.ts
 interface ElementDecorator {
   (): PropertyDecorator;
@@ -41,6 +43,27 @@ interface HTMLStencilElement extends HTMLElement {
   componentOnReady(): Promise<this>;
 }
 type TagTransformer = (tag: string) => string;
+/**
+ * A constructor type that can be used as the base for mixin factories.
+ *
+ * ```ts
+ * import { MixedInCtor } from '@stencil/core';
+ *
+ * const AFactoryFn = <B extends MixedInCtor>(Base: B) => {class A extends Base { propA = A }; return A;}
+ * ```
+ */
+type MixedInCtor<T = {}> = new (...args: any[]) => T;
+/**
+ * A map of `@Prop`/`@State` property names to their new and previous
+ * values, passed to `componentShouldUpdate` once per render cycle.
+ *
+ * Pass `this` as `T` to type `changes` against your component's own
+ * members, e.g. `componentShouldUpdate(changes: ComponentShouldUpdateChanges<this>)`.
+ */
+type ComponentShouldUpdateChanges<T = any> = { [K in Extract<keyof T, string>]?: {
+  newVal: T[K];
+  oldVal: T[K];
+}; };
 interface ComponentInterface {
   connectedCallback?(): void;
   disconnectedCallback?(): void;
@@ -66,14 +89,18 @@ interface ComponentInterface {
    */
   componentDidLoad?(): void;
   /**
-   * A `@Prop` or `@State` property changed and a rerender is about to be requested.
+   * One or more `@Prop` or `@State` properties changed and a rerender is
+   * about to be requested. `changes` contains every property that changed
+   * since the last render, keyed by property name.
    *
-   * Called multiple times throughout the life of
-   * the component as its properties change.
+   * Called once per render cycle, batching all properties that changed
+   * synchronously since the last render.
+   *
+   * Return `false` to prevent the pending render.
    *
    * componentShouldUpdate is not called on the first render.
    */
-  componentShouldUpdate?(newVal: any, oldVal: any, propName: string): boolean | void;
+  componentShouldUpdate?(changes: ComponentShouldUpdateChanges<this>): boolean | void;
   /**
    * The component is about to update and re-render.
    *
@@ -96,6 +123,44 @@ interface ComponentInterface {
   render?(): any;
   [memberName: string]: any;
 }
+/**
+ * A reusable behavior that hooks into a `ReactiveControllerHost`'s lifecycle. Modeled after Lit's
+ * `ReactiveController` pattern: implement the hooks you need, then register an instance with a host
+ * via `host.addController(this)`.
+ */
+interface ReactiveController {
+  hostConnected?(): void;
+  hostDisconnected?(): void;
+  hostWillLoad?(): Promise<void> | void;
+  hostDidLoad?(): void;
+  hostWillRender?(): Promise<void> | void;
+  hostDidRender?(): void;
+  hostWillUpdate?(): Promise<void> | void;
+  hostDidUpdate?(): void;
+}
+/**
+ * The shape added to a component by mixing in `ReactiveControllerHost` (see below).
+ */
+interface ReactiveControllerHostInterface extends ComponentInterface, HTMLElement {
+  readonly controllers: ReadonlySet<ReactiveController>;
+  addController(controller: ReactiveController): void;
+  removeController(controller: ReactiveController): void;
+  requestUpdate(): void;
+  /**
+   * Resolves once the next pending render commits. Matches the shape of Lit's
+   * `ReactiveControllerHost.updateComplete`, for interop with controllers written against Lit's API
+   * (e.g. `@lit/context`).
+   */
+  readonly updateComplete: Promise<boolean>;
+}
+/**
+ * Minimal interface matched by signal objects (from @stencil/core/signals).
+ * Used in JSX attribute types.
+ */
+interface SignalRef<T = any> {
+  readonly value: T;
+  peek(): T;
+}
 /**
  * Utilities for working with functional Stencil components. An object
  * conforming to this interface is passed by the Stencil runtime as the third
@@ -137,7 +202,7 @@ interface FunctionalUtilities {
   map: (children: VNode[], cb: (vnode: ChildNode$1, index: number, array: ChildNode$1[]) => ChildNode$1) => VNode[];
 }
 interface FunctionalComponent<T = {}> {
-  (props: T, children: VNode[], utils: FunctionalUtilities): VNode | VNode[] | null;
+  (props: T, children: VNode[], utils: FunctionalUtilities): VNode | null;
 }
 /**
  * A Child VDOM node
@@ -148,7 +213,7 @@ interface FunctionalComponent<T = {}> {
  * {@link FunctionalUtilities}).
  */
 interface ChildNode$1 {
-  vtag?: string | number | Function;
+  vtag?: string | number | Function | symbol | null;
   vkey?: string | number;
   vtext?: string;
   vchildren?: VNode[];
@@ -160,13 +225,15 @@ interface ChildNode$1 {
  */
 interface VNode {
   $flags$: number;
-  $tag$: string | number | Function;
+  $tag$: string | number | Function | symbol | null;
   $elm$: any;
   $text$: string;
   $children$: VNode[];
   $attrs$?: any;
   $name$?: string;
   $key$?: string | number;
+  /** Signal reference for vdom bypass: signal text nodes store the signal here. */
+  $signal$?: any;
 }
 declare namespace JSXBase {
   interface IntrinsicElements {
@@ -424,6 +491,7 @@ declare namespace JSXBase {
     onClose?: (event: Event) => void;
     open?: boolean;
     returnValue?: string;
+    closedby?: 'any' | 'closerequest' | 'none';
   }
   interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
     height?: number | string;
@@ -461,6 +529,8 @@ declare namespace JSXBase {
     allowtransparency?: string | boolean;
     frameBorder?: number | string;
     frameborder?: number | string;
+    fetchPriority?: 'high' | 'low' | 'auto';
+    fetchpriority?: 'high' | 'low' | 'auto';
     importance?: 'low' | 'auto' | 'high';
     height?: number | string;
     loading?: 'lazy' | 'auto' | 'eager';
@@ -483,9 +553,12 @@ declare namespace JSXBase {
     crossOrigin?: string;
     crossorigin?: string;
     decoding?: 'async' | 'auto' | 'sync';
+    fetchPriority?: 'high' | 'low' | 'auto';
+    fetchpriority?: 'high' | 'low' | 'auto';
     importance?: 'low' | 'auto' | 'high';
     height?: number | string;
     loading?: 'lazy' | 'auto' | 'eager';
+    referrerPolicy?: ReferrerPolicy;
     sizes?: string;
     src?: string;
     srcSet?: string;
@@ -581,6 +654,8 @@ declare namespace JSXBase {
   }
   interface LinkHTMLAttributes<T> extends HTMLAttributes<T> {
     as?: string;
+    fetchPriority?: 'high' | 'low' | 'auto';
+    fetchpriority?: 'high' | 'low' | 'auto';
     href?: string;
     hrefLang?: string;
     hreflang?: string;
@@ -704,6 +779,8 @@ declare namespace JSXBase {
     crossOrigin?: string;
     crossorigin?: string;
     defer?: boolean;
+    fetchPriority?: 'high' | 'low' | 'auto';
+    fetchpriority?: 'high' | 'low' | 'auto';
     importance?: 'low' | 'auto' | 'high';
     integrity?: string;
     nonce?: string;
@@ -801,7 +878,7 @@ declare namespace JSXBase {
     autofocus?: boolean | string;
     class?: string | {
       [className: string]: boolean;
-    };
+    } | SignalRef<string>;
     contentEditable?: boolean | string;
     contenteditable?: boolean | string;
     contextMenu?: string;
@@ -819,7 +896,10 @@ declare namespace JSXBase {
     tabIndex?: number;
     tabindex?: number | string;
     title?: string;
+    translate?: 'yes' | 'no' | (string & {});
     popover?: string | null;
+    focusgroup?: string;
+    focusgroupstart?: boolean;
     inputMode?: string;
     inputmode?: string;
     enterKeyHint?: string;
@@ -860,7 +940,7 @@ declare namespace JSXBase {
   interface SVGAttributes<T = SVGElement> extends DOMAttributes<T> {
     class?: string | {
       [className: string]: boolean;
-    };
+    } | SignalRef<string>;
     color?: string;
     height?: number | string;
     id?: string;
@@ -1261,10 +1341,13 @@ declare namespace JSXBase {
 interface JSXAttributes<T = Element$1> {
   key?: string | number;
   ref?: (elm?: T) => void;
+  children?: any;
 }
 interface CustomElementsDefineOptions {
   exclude?: string[];
   syncQueue?: boolean;
+  /** Scoped custom element registry to define components in. Defaults to the global registry. */
+  registry?: CustomElementRegistry;
   jmp?: (c: Function) => any;
   raf?: (c: FrameRequestCallback) => number;
   ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
@@ -1301,6 +1384,7 @@ interface BuildFeatures {
   vdomStyle: boolean;
   vdomText: boolean;
   vdomXlink: boolean;
+  vdomSignals: boolean;
   slotRelocation: boolean;
   patchAll: boolean;
   patchChildren: boolean;
@@ -1347,21 +1431,27 @@ interface BuildConditionals extends Partial<BuildFeatures> {
   lazyLoad?: boolean;
   profile?: boolean;
   constructableCSS?: boolean;
-  appendChildSlotFix?: boolean;
-  slotChildNodesFix?: boolean;
-  scopedSlotTextContentFix?: boolean;
-  cloneNodeFix?: boolean;
+  /** True when `compat.lightDomPatches === true` - enables `applyLightDomPatches` shortcut. */
+  lightDomPatches?: boolean;
+  /** Patch `childNodes`/`children` getters on light-dom slotted components. */
+  slotChildNodes?: boolean;
+  /** Patch `cloneNode()` on light-dom slotted components. */
+  slotCloneNode?: boolean;
+  /** Patch `appendChild`/`insertBefore`/`removeChild` on light-dom slotted components. */
+  slotDomMutations?: boolean;
+  /** Patch `textContent` on light-dom slotted components. */
+  slotTextContent?: boolean;
   hydratedAttribute?: boolean;
   hydratedClass?: boolean;
   hydratedSelectorName?: string;
+  /** True when a global-style input contains `@import "stencil-hydrate"` - suppresses dynamic style injection in the loader. */
+  staticHydrationStyles?: boolean;
   initializeNextTick?: boolean;
-  shadowDomShim?: boolean;
   asyncQueue?: boolean;
   additionalTagTransformers?: boolean | 'prod';
-  attachStyles?: boolean;
-  experimentalSlotFixes?: boolean;
-  experimentalScopedSlotChanges?: boolean;
-  addGlobalStyleToComponents?: boolean | 'client';
+  signalBacking?: boolean;
+  /** True when JSX signal bypass is active - text nodes and attributes backed by Signal objects update the DOM directly. Auto-enabled when `signalBacking: true`. */
+  vdomSignals?: boolean;
 }
 interface ComponentConstructor {
   is?: string;
@@ -1426,7 +1516,7 @@ interface HostElement extends HTMLElement {
   disconnectedCallback?: () => void;
   host?: Element;
   forceUpdate?: () => void;
-  __stencil__getHostRef?: () => HostRef;
+  __s_ghr?: () => HostRef;
   /**
    * Unique stencil id for this element
    */
@@ -1480,6 +1570,15 @@ interface HostElement extends HTMLElement {
    * must be resolved for the top, ancestor component to be fully hydrated
    */
   ['s-p']?: Promise<void>[];
+  /**
+   * Pending Connects:
+   * A list of {@link HostRef.$onFirstConnectPromise$} promises for descendants that
+   * were already registered with this component (their nearest Stencil ancestor) by
+   * the time this component's own initial `componentWillLoad` was scheduled. Awaited
+   * so this component's `componentWillLoad` can't fire before those descendants'
+   * real `connectedCallback`s have.
+   */
+  ['s-pc']?: Promise<void>[];
   componentOnReady?: () => Promise<this>;
 }
 /**
@@ -1519,6 +1618,11 @@ interface RenderNode extends HostElement {
    * Slot name of either the slot itself or the slotted node
    */
   ['s-sn']?: string;
+  /**
+   * `slot` attribute of a `<slot>` reference rendered as a text node (no fallback content),
+   * since text nodes can't carry real DOM attributes.
+   */
+  ['s-sa']?: string;
   /**
    * Host element tag name:
    * The tag name of the host element that this
@@ -1571,64 +1675,64 @@ interface RenderNode extends HostElement {
    * Used to know the components encapsulation.
    * empty "" for shadow, "c" from scoped
    */
-  ['s-en']?: '' | /*shadow*/'c';
+  ['s-en']?: '' | /*shadow*/ 'c';
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the internal `childNodes` of the component
    */
   readonly __childNodes?: NodeListOf<ChildNode>;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the internal `children` of the component
    */
   readonly __children?: HTMLCollectionOf<Element>;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the internal `firstChild` of the component
    */
   readonly __firstChild?: ChildNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the internal `lastChild` of the component
    */
   readonly __lastChild?: ChildNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the internal `textContent` of the component
    */
   __textContent?: string;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * gives access to the original `append` method
    */
   __append?: (...nodes: (Node | string)[]) => void;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * gives access to the original `prepend` method
    */
   __prepend?: (...nodes: (Node | string)[]) => void;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * gives access to the original `appendChild` method
    */
   __appendChild?: <T extends Node>(newChild: T) => T;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * gives access to the original `insertBefore` method
    */
   __insertBefore?: <T extends Node>(node: T, child: Node | null) => T;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * gives access to the original `removeChild` method
    */
   __removeChild?: <T extends Node>(child: T) => T;
@@ -1666,40 +1770,56 @@ interface PatchedSlotNode extends Node {
   ['s-sr']?: boolean;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the actual `parentNode` of the component
    */
   __parentNode?: RenderNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the actual `nextSibling` of the component
    */
   __nextSibling?: RenderNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the actual `previousSibling` of the component
    */
   __previousSibling?: RenderNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the actual `nextElementSibling` of the component
    */
   __nextElementSibling?: RenderNode;
   /**
    * On a `scoped: true` component
-   * with `experimentalSlotFixes` flag enabled,
+   * with `lightDomPatches` flag enabled,
    * returns the actual `nextElementSibling` of the component
    */
   __previousElementSibling?: RenderNode;
 }
 type LazyBundlesRuntimeData = LazyBundleRuntimeData[];
-type LazyBundleRuntimeData = [/** bundleIds */string, ComponentRuntimeMetaCompact[]];
-type ComponentRuntimeMetaCompact = [/** flags */number, /** tagname */string, /** members */{
+type LazyBundleRuntimeData = [
+/** bundleIds */
+string, ComponentRuntimeMetaCompact[]];
+type ComponentRuntimeMetaCompact = [
+/** flags */
+number,
+/** tagname */
+string,
+/** members */
+{
   [memberName: string]: ComponentRuntimeMember;
-}?, /** listeners */ComponentRuntimeHostListener[]?, /** watchers */ComponentConstructorChangeHandlers?, /** serializers */ComponentConstructorChangeHandlers?, /** deserializers */ComponentConstructorChangeHandlers?];
+}?,
+/** listeners */
+ComponentRuntimeHostListener[]?,
+/** watchers */
+ComponentConstructorChangeHandlers?,
+/** serializers */
+ComponentConstructorChangeHandlers?,
+/** deserializers */
+ComponentConstructorChangeHandlers?];
 /**
  * Runtime metadata for a Stencil component
  */
@@ -1791,7 +1911,7 @@ type ComponentRuntimeReflectingAttr = [string, string | undefined];
  * associated {@link HostRef} instance.
  */
 type RuntimeRef = HostElement | {
-  __stencil__getHostRef?: () => HostRef;
+  __s_ghr?: () => HostRef;
 };
 /**
  * Interface used to track an Element, it's virtual Node (`VNode`), and other data
@@ -1802,6 +1922,14 @@ interface HostRef {
   $cmpMeta$: ComponentRuntimeMeta;
   $hostElement$: HostElement;
   $instanceValues$?: Map<string, any>;
+  /**
+   * Prop/state changes accumulated since the last render, flushed to
+   * `componentShouldUpdate` once per render cycle.
+   */
+  $queuedPropChanges$?: ComponentShouldUpdateChanges;
+  $signalValues$?: Map<string, import('@preact/signals-core').Signal<any>>;
+  /** Dispose function that tears down all signal effects for this component. */
+  $signalCleanup$?: () => void;
   $serializerValues$?: Map<string, string>;
   $lazyInstance$?: ComponentInterface;
   /**
@@ -1834,6 +1962,21 @@ interface HostRef {
    * It is called after {@link HostRef.$onInstancePromise$} resolves.
    */
   $onRenderResolve$?: () => void;
+  /**
+   * A promise that resolves once this component's real `connectedCallback` has fired
+   * for the first time. Created lazily - either by a descendant that needs to wait for
+   * this component's connection before firing its own real `connectedCallback`
+   * ({@link HOST_FLAGS.hasFiredConnected}), or by this component registering itself
+   * with its nearest Stencil ancestor's `s-pc` list. This is what lets a component's
+   * real `connectedCallback` (and, transitively, a pending ancestor's initial
+   * `componentWillLoad`) stay ordered correctly regardless of which of an
+   * ancestor/descendant pair's lazy module happens to resolve first.
+   */
+  $onFirstConnectPromise$?: Promise<void>;
+  /**
+   * A callback which resolves {@link HostRef.$onFirstConnectPromise$}
+   */
+  $onFirstConnectResolve$?: () => void;
   $vnode$?: VNode;
   $queuedListeners$?: [string, any][];
   $rmListeners$?: (() => void)[];
@@ -1843,6 +1986,11 @@ interface HostRef {
    * Defer connectedCallback until after first render for components with slot relocation.
    */
   $deferredConnectedCallback$?: boolean;
+  /**
+   * The number of times this host's lazy component load has failed and been retried.
+   * Used to give up retrying after {@link MAX_LAZY_LOAD_RETRIES} failed attempts.
+   */
+  $loadRetryCount$?: number;
 }
 interface PlatformRuntime {
   /**
@@ -1888,4 +2036,31 @@ interface PlatformRuntime {
 }
 type ChildType = VNode | number | string;
 //#endregion
-export { ResolutionHandler as _, ComponentRuntimeMeta as a, HostRef as c, RenderNode as d, RuntimeRef as f, JSXBase as g, HTMLStencilElement as h, ComponentRuntimeHostListener as i, LazyBundlesRuntimeData as l, FunctionalComponent as m, ChildType as n, ComponentRuntimeMetaCompact as o, CustomElementsDefineOptions as p, ComponentConstructor as r, HostElement as s, BuildConditionals as t, PlatformRuntime as u, TagTransformer as v, VNode as y };
+//#region src/app-data/index.d.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`.
+ */
+declare const BUILD: BuildConditionals;
+declare const Env: {};
+declare const NAMESPACE: string;
+//#endregion
+export { ResolutionHandler as C, ReactiveControllerHostInterface as S, VNode as T, CustomElementsDefineOptions as _, ComponentConstructor as a, JSXBase as b, ComponentRuntimeMeta as c, HostRef as d, LazyBundlesRuntimeData as f, ComponentInterface as g, RuntimeRef as h, ChildType as i, ComponentRuntimeMetaCompact as l, RenderNode as m, Env as n, ComponentConstructorChangeHandlers as o, PlatformRuntime as p, NAMESPACE as r, ComponentRuntimeHostListener as s, BUILD as t, HostElement as u, FunctionalComponent as v, TagTransformer as w, MixedInCtor as x, HTMLStencilElement as y };

package/dist/index-VK8okIiF.d.mts

@@ -0,0 +1,108 @@
+import { Ca as VNode, Et as HostElement, Sa as UserBuildConditionals, ba as ResolutionHandler, cn as RuntimeRef, ga as FunctionalComponent, ha as ErrorHandler, p as ChildType, va as RafCallback, xa as TagTransformer } from "./index-BHj3EBl2.mjs";
+//#region src/client/client-build.d.ts
+declare const Build: UserBuildConditionals;
+//#endregion
+//#region src/client/client-log.d.ts
+declare const setErrorHandler: (handler: ErrorHandler) => ErrorHandler;
+//#endregion
+//#region src/client/client-task-queue.d.ts
+declare const readTask: (cb: RafCallback) => void;
+declare const writeTask: (cb: RafCallback) => void;
+//#endregion
+//#region src/client/client-window.d.ts
+declare const setPlatformHelpers: (helpers: {
+  jmp?: (c: any) => any;
+  raf?: (c: any) => number;
+  ael?: (el: any, eventName: string, listener: any, options: any) => void;
+  rel?: (el: any, eventName: string, listener: any, options: any) => void;
+  ce?: (eventName: string, opts?: any) => any;
+}) => void;
+//#endregion
+//#region src/app-data/index.d.ts
+declare const Env: {};
+//#endregion
+//#region src/runtime/element.d.ts
+declare const getElement: (ref: any) => HostElement;
+/**
+ * Get the shadow root for a Stencil component's host element.
+ * This works for both open and closed shadow DOM modes.
+ *
+ * For closed shadow DOM, `element.shadowRoot` returns `null` by design,
+ * but Stencil stores the reference internally so components can still
+ * access their own shadow root.
+ *
+ * @param element The host element (from @Element() decorator)
+ * @returns The shadow root, or null if no shadow root exists
+ */
+declare const getShadowRoot: (element: HTMLElement) => ShadowRoot | null;
+//#endregion
+//#region src/runtime/event-emitter.d.ts
+declare const createEvent: (ref: RuntimeRef, name: string, flags: number) => {
+  emit: (detail: any) => CustomEvent<any>;
+};
+//#endregion
+//#region src/runtime/fragment.d.ts
+declare const Fragment: FunctionalComponent;
+//#endregion
+//#region src/runtime/mode.d.ts
+declare const setMode: (handler: ResolutionHandler) => number;
+declare const getMode: (ref: RuntimeRef) => string;
+//#endregion
+//#region src/runtime/render.d.ts
+/**
+ * Method to render a virtual DOM tree to a container element.
+ *
+ * Supports efficient re-renders: calling `render()` again on the same container
+ * will diff the new VNode tree against the previous one and only update what changed,
+ * preserving existing DOM elements and their state.
+ *
+ * @example
+ * ```tsx
+ * import { render } from '@stencil/core';
+ *
+ * const vnode = (
+ *   <div>
+ *     <h1>Hello, world!</h1>
+ *   </div>
+ * );
+ * render(vnode, document.body);
+ * ```
+ *
+ * @param vnode - The virtual DOM tree to render
+ * @param container - The container element to render the virtual DOM tree to
+ */
+declare function render(vnode: VNode, container: Element): void;
+//#endregion
+//#region src/runtime/tag-transform.d.ts
+/**
+ * Transforms a tag name using the current tag transformer
+ * @param tag - the tag to transform e.g. `my-tag`
+ * @returns the transformed tag e.g. `new-my-tag`
+ */
+declare function transformTag<T extends string>(tag: T): T;
+/**
+ * Sets the tag transformer to be used when rendering custom elements
+ * @param transformer the transformer function to use. Must return a string
+ */
+declare function setTagTransformer(transformer: TagTransformer): void;
+//#endregion
+//#region src/runtime/update-component.d.ts
+declare const getRenderingRef: () => any;
+declare const forceUpdate: (ref: any) => boolean;
+//#endregion
+//#region src/runtime/vdom/h.d.ts
+declare const h: (nodeName: any, vnodeData: any, ...children: ChildType[]) => VNode;
+declare const Host: {};
+//#endregion
+//#region src/runtime/vdom/jsx-runtime.d.ts
+declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * @alias
+ */
+declare const jsxs: typeof jsx;
+/**
+ * @alias
+ */
+declare const jsxDEV: typeof jsx;
+//#endregion
+export { Build as S, Env as _, h as a, writeTask as b, setTagTransformer as c, getMode as d, setMode as f, getShadowRoot as g, getElement as h, Host as i, transformTag as l, createEvent as m, jsxDEV as n, forceUpdate as o, Fragment as p, jsxs as r, getRenderingRef as s, jsx as t, render as u, setPlatformHelpers as v, setErrorHandler as x, readTask as y };

package/dist/index.d.mts

@@ -11,6 +11,7 @@ export type {
   ComponentDidUpdate,
   ComponentInterface,
   ComponentOptions,
+  ComponentShouldUpdateChanges,
   ComponentWillLoad,
   ComponentWillUpdate,
   EventEmitter,
@@ -25,6 +26,8 @@ export type {
   PropOptions,
   QueueApi,
   RafCallback,
+  ReactiveController,
+  ReactiveControllerHostInterface,
   VNode,
   VNodeData,
 } from './declarations/stencil-public-runtime';
@@ -51,9 +54,9 @@ export {
   Method,
   MixedInCtor,
   Mixin,
-  MixinFactory,
   Prop,
   readTask,
+  ReactiveControllerHost,
   render,
   resolveVar,
   setAssetPath,