@stencil/core 5.0.0-alpha.8 → 5.0.0-beta.0

package/dist/runtime/client/runtime.d.ts

@@ -1,4 +1,6 @@
-import { BUILD, Env, NAMESPACE } from "@stencil/core/runtime/app-data";
+import { BUILD, Env, NAMESPACE } from "@stencil/core/app-data";
+import "rolldown";
+import "typescript";
 //#region src/declarations/stencil-public-runtime.d.ts
 interface ElementDecorator {
   (): PropertyDecorator;
@@ -49,6 +51,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;
@@ -74,14 +97,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.
    *
@@ -104,6 +131,36 @@ 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>;
+}
 interface RafCallback {
   (timeStamp: number): void;
 }
@@ -445,6 +502,7 @@ declare namespace JSXBase {
     onClose?: (event: Event$1) => void;
     open?: boolean;
     returnValue?: string;
+    closedby?: 'any' | 'closerequest' | 'none';
   }
   interface EmbedHTMLAttributes<T> extends HTMLAttributes<T> {
     height?: number | string;
@@ -482,6 +540,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';
@@ -504,6 +564,8 @@ 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';
@@ -603,6 +665,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;
@@ -726,6 +790,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;
@@ -841,7 +907,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;
@@ -1599,6 +1668,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>;
 }
 /**
@@ -1638,6 +1716,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
@@ -1690,7 +1773,7 @@ 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 `lightDomPatches` flag enabled,
@@ -1815,10 +1898,26 @@ interface PatchedSlotNode extends Node {
   __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
  */
@@ -1921,6 +2020,11 @@ 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;
@@ -1956,6 +2060,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)[];
@@ -1965,6 +2084,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 {
   /**
@@ -2010,6 +2134,18 @@ interface PlatformRuntime {
 }
 type StyleMap = Map<string, CSSStyleSheet | string>;
 type ChildType = VNode | number | string;
+type PropsType = VNodeProdData | number | string | null;
+interface VNodeProdData {
+  key?: string | number;
+  class?: {
+    [className: string]: boolean;
+  } | string;
+  className?: {
+    [className: string]: boolean;
+  } | string;
+  style?: any;
+  [key: string]: any;
+}
 //#endregion
 //#region src/client/client-build.d.ts
 declare const Build: UserBuildConditionals;
@@ -2318,6 +2454,9 @@ declare const setPlatformOptions: (opts: SetPlatformOptions) => PlatformRuntime
  */
 declare const proxyComponent: (Cstr: ComponentConstructor, cmpMeta: ComponentRuntimeMeta, flags: number) => ComponentConstructor;
 //#endregion
+//#region src/runtime/reactive-controller.d.ts
+declare const ReactiveControllerHost: <B extends MixedInCtor<ComponentInterface & HTMLElement>>(Base: B) => B & MixedInCtor<ReactiveControllerHostInterface>;
+//#endregion
 //#region src/runtime/render.d.ts
 /**
  * Method to render a virtual DOM tree to a container element.
@@ -2369,7 +2508,7 @@ declare const postUpdateComponent: (hostRef: HostRef) => void;
 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 h: (nodeName: any, vnodeData: PropsType, ...children: ChildType[]) => VNode;
 declare const Host: {};
 //#endregion
 //#region src/runtime/vdom/jsx-runtime.d.ts
@@ -2383,32 +2522,4 @@ declare const jsxs: typeof jsx;
  */
 declare const jsxDEV: typeof jsx;
 //#endregion
-//#region src/runtime/vdom/vdom-annotations.d.ts
-/**
- * Updates the DOM generated on the server with annotations such as node attributes and
- * comment nodes to facilitate future client-side hydration. These annotations are used for things
- * like moving elements back to their original hosts if using Shadow DOM on the client, and for quickly
- * reconstructing the vNode representations of the DOM.
- *
- * @param doc The DOM generated by the server.
- * @param staticComponents Any components that should be considered static and do not need client-side hydration.
- */
-declare const insertVdomAnnotations: (doc: Document, staticComponents: string[]) => void;
-//#endregion
-//#region src/runtime/vdom/vdom-render.d.ts
-/**
- * The main entry point for Stencil's virtual DOM-based rendering engine
- *
- * Given a {@link d.HostRef} container and some virtual DOM nodes, this
- * function will handle creating a virtual DOM tree with a single root, patching
- * the current virtual DOM tree onto an old one (if any), dealing with slot
- * relocation, and reflecting attributes.
- *
- * @param hostRef data needed to root and render the virtual DOM tree, such as
- * the DOM node into which it should be rendered.
- * @param renderFnResults the virtual DOM nodes to be rendered
- * @param isInitialLoad whether or not this is the first call after page load
- */
-declare const renderVdom: (hostRef: HostRef, renderFnResults: VNode | VNode[], isInitialLoad?: boolean) => void;
-//#endregion
-export { AttachInternals, AttrDeserialize, BUILD, Build, Component, Element$1 as Element, Env, Event, Fragment, H, H as HTMLElement, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Listen, Method, Mixin, NAMESPACE, Prop, PropSerialize, STENCIL_DEV_MODE, State, Watch, addHostEventListeners, bootstrapLazy, cmpModules, connectedCallback, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRegistry, getRenderingRef, getShadowRoot, getValue, h, insertVdomAnnotations, isMemberInElement, jsx, jsxDEV, jsxs, loadModule, modeResolutionChain, needsScopedSSR, nextTick, normalizeWatchers, parsePropertyValue, plt, postUpdateComponent, promiseResolve, proxyComponent, proxyCustomElement, readTask, registerHost, registerInstance, render, renderVdom, resolveVar, setAssetPath, setErrorHandler, setLazyLoadBasePath, setMode, setNonce, setPlatformHelpers, setPlatformOptions, setRegistry, setScopedSsr, setTagTransformer, setValue, styles, supportsConstructableStylesheets, supportsListenerOptions, supportsMutableAdoptedStyleSheets, transformTag, win, writeTask };
+export { AttachInternals, AttrDeserialize, BUILD, Build, Component, Element$1 as Element, Env, Event, Fragment, H, H as HTMLElement, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Listen, Method, Mixin, NAMESPACE, Prop, PropSerialize, ReactiveControllerHost, STENCIL_DEV_MODE, State, Watch, addHostEventListeners, bootstrapLazy, cmpModules, connectedCallback, consoleDevError, consoleDevInfo, consoleDevWarn, consoleError, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getHostRef, getMode, getRegistry, getRenderingRef, getShadowRoot, getValue, h, isMemberInElement, jsx, jsxDEV, jsxs, loadModule, modeResolutionChain, needsScopedSSR, nextTick, normalizeWatchers, parsePropertyValue, plt, postUpdateComponent, promiseResolve, proxyComponent, proxyCustomElement, readTask, registerHost, registerInstance, render, resolveVar, setAssetPath, setErrorHandler, setLazyLoadBasePath, setMode, setNonce, setPlatformHelpers, setPlatformOptions, setRegistry, setScopedSsr, setTagTransformer, setValue, styles, supportsConstructableStylesheets, supportsListenerOptions, supportsMutableAdoptedStyleSheets, transformTag, win, writeTask };