@stencil/core 4.43.2 → 5.0.0-next.0

package/dist/runtime/index.d.ts

@@ -0,0 +1,221 @@
+import { _ as ResolutionHandler, a as ComponentRuntimeMeta, c as HostRef, d as RenderNode, f as RuntimeRef, g as JSXBase, h as HTMLStencilElement, i as ComponentRuntimeHostListener, l as LazyBundlesRuntimeData, m as FunctionalComponent, n as ChildType, o as ComponentRuntimeMetaCompact, p as CustomElementsDefineOptions, r as ComponentConstructor, s as HostElement, u as PlatformRuntime, v as TagTransformer, y as VNode } from "../stencil-private-Cgcr414u.js";
+
+//#region src/runtime/asset-path.d.ts
+declare const getAssetPath: (path: string) => string;
+declare const setAssetPath: (path: string) => string;
+//#endregion
+//#region src/runtime/bootstrap-custom-element.d.ts
+declare const defineCustomElement: (Cstr: any, compactMeta: ComponentRuntimeMetaCompact) => void;
+declare const proxyCustomElement: (Cstr: any, compactMeta: ComponentRuntimeMetaCompact) => any;
+declare const forceModeUpdate: (elm: RenderNode) => void;
+//#endregion
+//#region src/runtime/bootstrap-lazy.d.ts
+declare const bootstrapLazy: (lazyBundles: LazyBundlesRuntimeData, options?: CustomElementsDefineOptions) => void;
+//#endregion
+//#region src/runtime/connected-callback.d.ts
+declare const connectedCallback: (elm: HostElement) => void;
+//#endregion
+//#region src/runtime/disconnected-callback.d.ts
+declare const disconnectedCallback: (elm: HostElement) => Promise<void>;
+//#endregion
+//#region src/runtime/element.d.ts
+declare const getElement: (ref: any) => HostElement;
+//#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/host-listener.d.ts
+declare const addHostEventListeners: (elm: HostElement, hostRef: HostRef, listeners?: ComponentRuntimeHostListener[], attachParentListeners?: boolean) => void;
+//#endregion
+//#region src/runtime/mixin.d.ts
+type Ctor<T = {}> = new (...args: any[]) => T;
+declare function Mixin(...mixins: ((base: Ctor) => Ctor)[]): Ctor<{}>;
+//#endregion
+//#region src/runtime/mode.d.ts
+declare const setMode: (handler: ResolutionHandler) => number;
+declare const getMode: (ref: RuntimeRef) => string;
+//#endregion
+//#region src/runtime/nonce.d.ts
+/**
+ * Assigns the given value to the nonce property on the runtime platform object.
+ * During runtime, this value is used to set the nonce attribute on all dynamically created script and style tags.
+ * @param nonce The value to be assigned to the platform nonce property.
+ * @returns void
+ */
+declare const setNonce: (nonce: string) => string;
+//#endregion
+//#region src/runtime/parse-property-value.d.ts
+/**
+ * Parse a new property value for a given property type.
+ *
+ * While the prop value can reasonably be expected to be of `any` type as far as TypeScript's type checker is concerned,
+ * it is not safe to assume that the string returned by evaluating `typeof propValue` matches:
+ *   1. `any`, the type given to `propValue` in the function signature
+ *   2. the type stored from `propType`.
+ *
+ * This function provides the capability to parse/coerce a property's value to potentially any other JavaScript type.
+ *
+ * Property values represented in TSX preserve their type information. In the example below, the number 0 is passed to
+ * a component. This `propValue` will preserve its type information (`typeof propValue === 'number'`). Note that is
+ * based on the type of the value being passed in, not the type declared of the class member decorated with `@Prop`.
+ * ```tsx
+ * <my-cmp prop-val={0}></my-cmp>
+ * ```
+ *
+ * HTML prop values on the other hand, will always a string
+ *
+ * @param propValue the new value to coerce to some type
+ * @param propType the type of the prop, expressed as a binary number
+ * @param isFormAssociated whether the component is form-associated (optional)
+ * @returns the parsed/coerced value
+ */
+declare const parsePropertyValue: (propValue: unknown, propType: number, isFormAssociated?: boolean) => any;
+//#endregion
+//#region src/runtime/platform-options.d.ts
+interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  ce?: (eventName: string, opts?: any) => CustomEvent;
+}
+declare const setPlatformOptions: (opts: SetPlatformOptions) => PlatformRuntime & SetPlatformOptions;
+//#endregion
+//#region src/runtime/proxy-component.d.ts
+/**
+ * Attach a series of runtime constructs to a compiled Stencil component
+ * constructor, including getters and setters for the `@Prop` and `@State`
+ * decorators, callbacks for when attributes change, and so on.
+ *
+ * On a lazy loaded component, this is wired up to both the class instance
+ * and the element separately. A `hostRef` keeps the 2 in sync.
+ *
+ * On a traditional component, this is wired up to the element only.
+ *
+ * @param Cstr the constructor for a component that we need to process
+ * @param cmpMeta metadata collected previously about the component
+ * @param flags a number used to store a series of bit flags
+ * @returns a reference to the same constructor passed in (but now mutated)
+ */
+declare const proxyComponent: (Cstr: ComponentConstructor, cmpMeta: ComponentRuntimeMeta, flags: number) => ComponentConstructor;
+//#endregion
+//#region src/runtime/render.d.ts
+/**
+ * Method to render a virtual DOM tree to a container element.
+ *
+ * @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/runtime-constants.d.ts
+declare const HYDRATED_STYLE_ID = "sty-id";
+//#endregion
+//#region src/runtime/set-value.d.ts
+declare const getValue: (ref: RuntimeRef, propName: string) => any;
+declare const setValue: (ref: RuntimeRef, propName: string, newVal: any, cmpMeta: ComponentRuntimeMeta) => 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 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 Host: {};
+//#endregion
+//#region src/runtime/vdom/jsx-dev-runtime.d.ts
+/**
+ * JSX development runtime function for creating elements with debug info.
+ * Called by TypeScript's jsx transform in development mode.
+ *
+ * @param type - The element type (string tag name or functional component)
+ * @param props - The element props (includes children, key, etc.)
+ * @param key - The element's key (passed separately in dev mode)
+ * @param isStaticChildren - Whether children are static (optimization hint)
+ * @param source - Source location information for debugging
+ * @param self - The component instance (for debugging)
+ * @returns A virtual DOM node
+ */
+declare function jsxDEV(type: any, props: any, key?: string | number, _isStaticChildren?: boolean, _source?: any, _self?: any): VNode;
+//#endregion
+//#region src/runtime/vdom/jsx-runtime.d.ts
+/**
+ * JSX runtime function for creating elements in production mode.
+ * Called by TypeScript's jsx transform for elements without static children.
+ *
+ * @param type - The element type (string tag name or functional component)
+ * @param props - The element props (includes children)
+ * @param key - Optional key for the element
+ * @returns A virtual DOM node
+ */
+declare function jsx(type: any, props: any, key?: string): VNode;
+/**
+ * JSX runtime function for creating elements with static children.
+ * Called by TypeScript's jsx transform as an optimization when children are static.
+ *
+ * @param type - The element type (string tag name or functional component)
+ * @param props - The element props (includes children)
+ * @param key - Optional key for the element
+ * @returns A virtual DOM node
+ */
+declare function jsxs(type: any, props: any, key?: string): VNode;
+//#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 { Fragment, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Mixin, addHostEventListeners, bootstrapLazy, connectedCallback, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, getValue, h, insertVdomAnnotations, jsx, jsxDEV, jsxs, parsePropertyValue, postUpdateComponent, proxyComponent, proxyCustomElement, render, renderVdom, setAssetPath, setMode, setNonce, setPlatformOptions, setTagTransformer, setValue, transformTag };