@stencil/core 4.43.5 → 5.0.0-alpha.10

package/dist/runtime/index.d.ts

@@ -0,0 +1,211 @@
+import { S as VNode, _ as FunctionalComponent, a as ComponentConstructor, b as ResolutionHandler, c as ComponentRuntimeMeta, d as HostRef, f as LazyBundlesRuntimeData, g as CustomElementsDefineOptions, h as RuntimeRef, i as ChildType, l as ComponentRuntimeMetaCompact, m as RenderNode, o as ComponentConstructorChangeHandlers, p as PlatformRuntime, s as ComponentRuntimeHostListener, u as HostElement, v as HTMLStencilElement, x as TagTransformer, y as JSXBase } from "../index-xAkMgLX_.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-standalone.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/registry.d.ts
+declare const setRegistry: (registry: CustomElementRegistry) => void;
+declare const getRegistry: () => CustomElementRegistry;
+//#endregion
+//#region src/runtime/bootstrap-loader.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;
+/**
+ * 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/host-listener.d.ts
+declare const addHostEventListeners: (elm: HostElement, hostRef: HostRef, listeners?: ComponentRuntimeHostListener[]) => 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/normalize-watchers.d.ts
+/**
+ * Normalizes watcher metadata to the current `{ [methodName]: flags }[]` format.
+ *
+ * Prior to Stencil 4.39.x (PR #6484), the `@Watch()` compiler emitted watcher
+ * handlers as a plain string array: `{ "min": ["minChanged"] }`. The new format
+ * wraps each entry in an object that carries option flags (e.g. `immediate`):
+ * `{ "min": [{ "minChanged": 0 }] }`.
+ *
+ * When a library (e.g. Ionic Framework) was compiled with an older Stencil compiler
+ * but consumed by an app using a newer Stencil runtime, the runtime's
+ * `Object.entries(watcher)` call receives a string and misinterprets its character
+ * indices as method names, causing:
+ *   `TypeError: instance[watchMethodName] is not a function`
+ *
+ * This helper should be used at `$watchers$` assignment sites that need to
+ * accept both legacy and current compiler metadata so downstream code on those
+ * paths can safely assume the new object format.
+ *
+ * @param raw The raw watcher map from compiled metadata (new or legacy format).
+ * @returns A normalized watcher map in the `{ [methodName]: flags }[]` format, or `undefined` if `raw` is `undefined` or empty.
+ */
+declare const normalizeWatchers: (raw: ComponentConstructorChangeHandlers | undefined) => ComponentConstructorChangeHandlers | undefined;
+//#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.
+ *
+ * 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/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-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 { Fragment, type HTMLStencilElement, HYDRATED_STYLE_ID, Host, type JSXBase, Mixin, addHostEventListeners, bootstrapLazy, connectedCallback, createEvent, defineCustomElement, disconnectedCallback, forceModeUpdate, forceUpdate, getAssetPath, getElement, getMode, getRegistry, getRenderingRef, getShadowRoot, getValue, h, jsx, jsxDEV, jsxs, normalizeWatchers, parsePropertyValue, postUpdateComponent, proxyComponent, proxyCustomElement, render, setAssetPath, setMode, setNonce, setPlatformOptions, setRegistry, setTagTransformer, setValue, transformTag };