@stencil/core 4.43.3 → 5.0.0-alpha.1

package/dist/index-fIuYTL9f.d.mts

@@ -0,0 +1,178 @@
+import { Ca as VNode, Ct as HostElement, Sa as UserBuildConditionals, _a as ErrorHandler, ba as ResolutionHandler, p as ChildType, pn as RuntimeRef, va as FunctionalComponent, xa as TagTransformer, ya as RafCallback } from "./index-D-LlB2nw.mjs";
+
+//#region src/client/client-build.d.ts
+declare const Build: UserBuildConditionals;
+//#endregion
+//#region src/client/client-decorators.d.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
+ */
+declare const Component: (_opts?: any) => ClassDecorator;
+/**
+ * No-op property decorator stub for @Element()
+ * @returns a property decorator that does nothing
+ */
+declare const Element$1: () => PropertyDecorator;
+/**
+ * No-op property decorator stub for @Event()
+ * @param _opts - event options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const Event: (_opts?: any) => PropertyDecorator;
+/**
+ * No-op property decorator stub for @AttachInternals()
+ * @param _opts - attach internals options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const AttachInternals: (_opts?: any) => PropertyDecorator;
+/**
+ * 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
+ */
+declare const Listen: (_eventName: string, _opts?: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @Method()
+ * @param _opts - method options (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const Method: (_opts?: any) => MethodDecorator;
+/**
+ * No-op property decorator stub for @Prop()
+ * @param _opts - prop options (ignored at runtime)
+ * @returns a property decorator that does nothing
+ */
+declare const Prop: (_opts?: any) => PropertyDecorator;
+/**
+ * No-op property decorator stub for @State()
+ * @returns a property decorator that does nothing
+ */
+declare const State: () => PropertyDecorator;
+/**
+ * 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
+ */
+declare const Watch: (_propName: any, _opts?: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @PropSerialize()
+ * @param _propName - property name to serialize (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const PropSerialize: (_propName: any) => MethodDecorator;
+/**
+ * No-op method decorator stub for @AttrDeserialize()
+ * @param _propName - property name to deserialize (ignored at runtime)
+ * @returns a method decorator that does nothing
+ */
+declare const AttrDeserialize: (_propName: any) => MethodDecorator;
+/**
+ * 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
+ */
+declare const resolveVar: <T>(variable: T) => string;
+//#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/asset-path.d.ts
+declare const getAssetPath: (path: string) => string;
+declare const setAssetPath: (path: string) => string;
+//#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/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/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/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
+export { State as A, Component as C, Method as D, Listen as E, resolveVar as M, Build as N, Prop as O, AttrDeserialize as S, Event as T, setPlatformHelpers as _, setTagTransformer as a, setErrorHandler as b, getMode as c, Fragment as d, createEvent as f, Env as g, setAssetPath as h, getRenderingRef as i, Watch as j, PropSerialize as k, setMode as l, getAssetPath as m, h as n, transformTag as o, getElement as p, forceUpdate as r, render as s, Host as t, Mixin as u, readTask as v, Element$1 as w, AttachInternals as x, writeTask as y };

package/{internal/stencil-core/index.d.ts → dist/index.d.mts}

@@ -1,4 +1,10 @@
-export type { StencilConfig as Config, PrerenderConfig } from '../stencil-public-compiler';
+/// <reference path="./declarations/stencil-ext-modules.d.ts" />
+
+export type {
+  StencilConfig as Config,
+  PrerenderConfig,
+} from './declarations/stencil-public-compiler';
+
 export type {
   ChildNode,
   ComponentDidLoad,
@@ -21,7 +27,8 @@ export type {
   RafCallback,
   VNode,
   VNodeData,
-} from '../stencil-public-runtime';
+} from './declarations/stencil-public-runtime';
+
 export {
   AttrDeserialize,
   PropSerialize,
@@ -58,4 +65,4 @@ export {
   transformTag,
   Watch,
   writeTask,
-} from '../stencil-public-runtime';
+} from './declarations/stencil-public-runtime';

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { A as Event, D as AttrDeserialize, E as AttachInternals, F as State, I as Watch, L as resolveVar, M as Method, N as Prop, O as Component, P as PropSerialize, R as Build, S as setPlatformHelpers, _ as h, a as Mixin, b as readTask, c as forceUpdate, f as getElement, g as Host, i as render, j as Listen, k as Element, l as getRenderingRef, m as setMode, n as setTagTransformer, o as Fragment, p as getMode, r as transformTag, v as getAssetPath, w as setErrorHandler, x as writeTask, y as setAssetPath } from "./client-B1nuvCd2.mjs";
+export { AttachInternals, AttrDeserialize, Build, Component, Element, Event, Fragment, Host, Listen, Method, Mixin, Prop, PropSerialize, State, Watch, forceUpdate, getAssetPath, getElement, getMode, getRenderingRef, h, readTask, render, resolveVar, setAssetPath, setErrorHandler, setMode, setPlatformHelpers, setTagTransformer, transformTag, writeTask };

package/dist/jsx-runtime-DBzBJLKk.d.ts

@@ -0,0 +1,28 @@
+import { m as FunctionalComponent, y as VNode } from "./index-BONzXKJt.js";
+
+//#region src/runtime/fragment.d.ts
+declare const Fragment: FunctionalComponent;
+//#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
+export { jsxs as n, Fragment as r, jsx as t };

package/dist/jsx-runtime.d.ts

@@ -0,0 +1,2 @@
+import { n as jsxs, r as Fragment, t as jsx } from "./jsx-runtime-DBzBJLKk.js";
+export { Fragment, jsx, jsxs };

package/dist/jsx-runtime.js

@@ -0,0 +1,2 @@
+import { d as Fragment, n as jsx, r as jsxs } from "./runtime-CF9DJtSu.js";
+export { Fragment, jsx, jsxs };

package/dist/mock-doc.d.mts

@@ -0,0 +1 @@
+export * from "@stencil/mock-doc";

package/dist/mock-doc.mjs

@@ -0,0 +1,2 @@
+export * from "@stencil/mock-doc";
+export {};