@stencil/core 5.0.0-alpha.27 → 5.0.0-alpha.29

package/dist/{index-xAkMgLX_.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,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>;
+}
 /**
  * Minimal interface matched by signal objects (from @stencil/core/signals).
  * Used in JSX attribute types.
@@ -434,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;
@@ -471,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';
@@ -493,6 +553,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';
@@ -592,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;
@@ -715,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;
@@ -830,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;
@@ -1501,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>;
 }
 /**
@@ -1540,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
@@ -1592,7 +1675,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,
@@ -1717,10 +1800,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
  */
@@ -1823,6 +1922,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;
@@ -1858,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)[];
@@ -1867,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 {
   /**
@@ -1939,4 +2063,4 @@ declare const BUILD: BuildConditionals;
 declare const Env: {};
 declare const NAMESPACE: string;
 //#endregion
-export { VNode as S, FunctionalComponent as _, ComponentConstructor as a, ResolutionHandler as b, ComponentRuntimeMeta as c, HostRef as d, LazyBundlesRuntimeData as f, CustomElementsDefineOptions 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, HTMLStencilElement as v, TagTransformer as x, JSXBase as y };
+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';
@@ -53,6 +56,7 @@ export {
   Mixin,
   Prop,
   readTask,
+  ReactiveControllerHost,
   render,
   resolveVar,
   setAssetPath,

package/dist/index.mjs

@@ -1,2 +1,91 @@
-import { B as Event, C as setAssetPath, E as setPlatformHelpers, G as State, H as Method, I as AttachInternals, J as Build, K as Watch, L as AttrDeserialize, N as setErrorHandler, R as Component, S as getAssetPath, T as writeTask, U as Prop, V as Listen, W as PropSerialize, a as transformTag, b as getElement, c as Fragment, d as setMode, g as getRenderingRef, h as forceUpdate, i as setTagTransformer, m as h, o as render, p as Host, q as resolveVar, s as Mixin, u as getMode, w as readTask, x as getShadowRoot, z as Element } from "./client-CvcvHKz4.mjs";
-export { AttachInternals, AttrDeserialize, Build, Component, Element, Event, Fragment, Host, Listen, Method, Mixin, Prop, PropSerialize, State, Watch, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, getShadowRoot, h, readTask, render, resolveVar, setAssetPath, setErrorHandler, setMode, setPlatformHelpers, setTagTransformer, transformTag, writeTask };
+import { C as setAssetPath, E as setPlatformHelpers, I as Build, N as setErrorHandler, S as getAssetPath, T as writeTask, a as transformTag, b as getElement, c as Mixin, d as setMode, g as getRenderingRef, h as forceUpdate, i as setTagTransformer, m as h, o as render, p as Host, s as ReactiveControllerHost, u as getMode, w as readTask, x as getShadowRoot } from "./client-D1MsT-Rp.mjs";
+import { t as Fragment } from "./fragment-Di1hWOC8.mjs";
+//#region src/client/client-decorators.ts
+/**
+* Runtime stubs for Stencil decorators.
+*
+* These decorators are compile-time metadata flags that Stencil's compiler parses
+* and transforms. At runtime, they do nothing - the actual component behavior is
+* wired up by the compiled output, not by these decorators.
+*
+* These stubs exist so that:
+* 1. Component classes can be instantiated directly in tests without going through
+*    Stencil's full compilation pipeline
+* 2. The decorators don't throw "X is not a function" errors when used outside
+*    of Stencil's build process
+*/
+/**
+* No-op class decorator stub for @Component()
+* @param _opts - component options (ignored at runtime)
+* @returns a class decorator that returns the target unchanged
+*/
+const Component = (_opts) => (target) => target;
+/**
+* No-op property decorator stub for @Element()
+* @returns a property decorator that does nothing
+*/
+const Element = () => () => {};
+/**
+* No-op property decorator stub for @Event()
+* @param _opts - event options (ignored at runtime)
+* @returns a property decorator that does nothing
+*/
+const Event = (_opts) => () => {};
+/**
+* No-op property decorator stub for @AttachInternals()
+* @param _opts - attach internals options (ignored at runtime)
+* @returns a property decorator that does nothing
+*/
+const AttachInternals = (_opts) => () => {};
+/**
+* No-op method decorator stub for @Listen()
+* @param _eventName - event name to listen for (ignored at runtime)
+* @param _opts - listen options (ignored at runtime)
+* @returns a method decorator that does nothing
+*/
+const Listen = (_eventName, _opts) => () => {};
+/**
+* No-op method decorator stub for @Method()
+* @param _opts - method options (ignored at runtime)
+* @returns a method decorator that does nothing
+*/
+const Method = (_opts) => () => {};
+/**
+* No-op property decorator stub for @Prop()
+* @param _opts - prop options (ignored at runtime)
+* @returns a property decorator that does nothing
+*/
+const Prop = (_opts) => () => {};
+/**
+* No-op property decorator stub for @State()
+* @returns a property decorator that does nothing
+*/
+const State = () => () => {};
+/**
+* No-op method decorator stub for @Watch()
+* @param _propName - property name to watch (ignored at runtime)
+* @param _opts - watch options (ignored at runtime)
+* @returns a method decorator that does nothing
+*/
+const Watch = (_propName, _opts) => () => {};
+/**
+* No-op method decorator stub for @PropSerialize()
+* @param _propName - property name to serialize (ignored at runtime)
+* @returns a method decorator that does nothing
+*/
+const PropSerialize = (_propName) => () => {};
+/**
+* No-op method decorator stub for @AttrDeserialize()
+* @param _propName - property name to deserialize (ignored at runtime)
+* @returns a method decorator that does nothing
+*/
+const AttrDeserialize = (_propName) => () => {};
+/**
+* No-op compile-time utility stub for resolveVar()
+* At runtime, this just returns the string representation of whatever is passed in.
+* @param variable - the variable to resolve
+* @returns the string representation of the variable
+*/
+const resolveVar = (variable) => String(variable);
+//#endregion
+export { AttachInternals, AttrDeserialize, Build, Component, Element, Event, Fragment, Host, Listen, Method, Mixin, Prop, PropSerialize, ReactiveControllerHost, State, Watch, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, getShadowRoot, h, readTask, render, resolveVar, setAssetPath, setErrorHandler, setMode, setPlatformHelpers, setTagTransformer, transformTag, writeTask };

package/dist/jsx-runtime.mjs

@@ -1,2 +1,3 @@
-import { c as Fragment, n as jsxDEV, r as jsxs, t as jsx } from "./client-CvcvHKz4.mjs";
+import { n as jsxDEV, r as jsxs, t as jsx } from "./client-D1MsT-Rp.mjs";
+import { t as Fragment } from "./fragment-Di1hWOC8.mjs";
 export { Fragment, jsx, jsxDEV, jsxs };