@vue/runtime-core 3.5.16 → 3.6.0-alpha.1

package/dist/runtime-core.d.ts

@@ -25,7 +25,6 @@ type RawSlots = {
 
 declare enum SchedulerJobFlags {
     QUEUED = 1,
-    PRE = 2,
     /**
      * Indicates whether the effect is allowed to recursively trigger itself
      * when managed by the scheduler.
@@ -41,11 +40,11 @@ declare enum SchedulerJobFlags {
      * responsibility to perform recursive state mutation that eventually
      * stabilizes (#1727).
      */
-    ALLOW_RECURSE = 4,
-    DISPOSED = 8
+    ALLOW_RECURSE = 2,
+    DISPOSED = 4
 }
 interface SchedulerJob extends Function {
-    id?: number;
+    order?: number;
     /**
      * flags can technically be undefined, but it can still be used in bitwise
      * operations just like 0.
@@ -55,11 +54,11 @@ interface SchedulerJob extends Function {
      * Attached by renderer.ts when setting up a component's render effect
      * Used to obtain component information when reporting max recursive updates.
      */
-    i?: ComponentInternalInstance;
+    i?: GenericComponentInstance;
 }
 type SchedulerJobs = SchedulerJob | SchedulerJob[];
 export declare function nextTick<T = void, R = void>(this: T, fn?: (this: T) => R): Promise<Awaited<R>>;
-export declare function queuePostFlushCb(cb: SchedulerJobs): void;
+export declare function queuePostFlushCb(jobs: SchedulerJobs, id?: number): void;
 
 export type ComponentPropsOptions<P = Data> = ComponentObjectPropsOptions<P> | string[];
 export type ComponentObjectPropsOptions<P = Data> = {
@@ -151,9 +150,23 @@ export type ExtractPublicPropTypes<O> = {
 } & {
     [K in keyof Pick<O, PublicOptionalKeys<O>>]?: InferPropType<O[K]>;
 };
+declare enum BooleanFlags {
+    shouldCast = 0,
+    shouldCastTrue = 1
+}
 export type ExtractDefaultPropTypes<O> = O extends object ? {
     [K in keyof Pick<O, DefaultKeys<O>>]: InferPropType<O[K]>;
 } : {};
+type NormalizedProp = PropOptions & {
+    [BooleanFlags.shouldCast]?: boolean;
+    [BooleanFlags.shouldCastTrue]?: boolean;
+};
+/**
+ * normalized value is a tuple of the actual normalized options
+ * and an array of prop keys that need value casting (booleans and defaults)
+ */
+type NormalizedProps = Record<string, NormalizedProp>;
+export type NormalizedPropsOptions = [NormalizedProps, string[]] | [];
 
 /**
  * Vue `<script setup>` compiler macro for declaring component props. The
@@ -419,7 +432,7 @@ export interface ObjectDirective<HostElement = any, Value = any, Modifiers exten
 }
 export type FunctionDirective<HostElement = any, V = any, Modifiers extends string = string, Arg extends string = string> = DirectiveHook<HostElement, any, V, Modifiers, Arg>;
 export type Directive<HostElement = any, Value = any, Modifiers extends string = string, Arg extends string = string> = ObjectDirective<HostElement, Value, Modifiers, Arg> | FunctionDirective<HostElement, Value, Modifiers, Arg>;
-type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>;
+export type DirectiveModifiers<K extends string = string> = Partial<Record<K, boolean>>;
 export type DirectiveArguments = Array<[Directive | undefined] | [Directive | undefined, any] | [Directive | undefined, any, string] | [Directive | undefined, any, string | undefined, DirectiveModifiers]>;
 /**
  * Adds directives to a VNode.
@@ -630,6 +643,7 @@ export declare function getTransitionRawChildren(children: VNode[], keepComment?
 export interface Renderer<HostElement = RendererElement> {
     render: RootRenderFunction<HostElement>;
     createApp: CreateAppFunction<HostElement>;
+    internals: RendererInternals;
 }
 export interface HydrationRenderer extends Renderer<Element | ShadowRoot> {
     hydrate: RootHydrateFunction;
@@ -665,6 +679,7 @@ interface RendererInternals<HostNode = RendererNode, HostElement = RendererEleme
     r: RemoveFn;
     m: MoveFn;
     mt: MountComponentFn;
+    umt: UnmountComponentFn;
     mc: MountChildrenFn;
     pc: PatchChildrenFn;
     pbc: PatchBlockChildrenFn;
@@ -676,11 +691,12 @@ n2: VNode, container: RendererElement, anchor?: RendererNode | null, parentCompo
 type MountChildrenFn = (children: VNodeArrayChildren, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean, start?: number) => void;
 type PatchChildrenFn = (n1: VNode | null, n2: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null, optimized: boolean) => void;
 type PatchBlockChildrenFn = (oldChildren: VNode[], newChildren: VNode[], fallbackContainer: RendererElement, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, slotScopeIds: string[] | null) => void;
-type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentSuspense?: SuspenseBoundary | null) => void;
+type MoveFn = (vnode: VNode, container: RendererElement, anchor: RendererNode | null, type: MoveType, parentComponent: ComponentInternalInstance | null, parentSuspense?: SuspenseBoundary | null) => void;
 type NextFn = (vnode: VNode) => RendererNode | null;
 type UnmountFn = (vnode: VNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, doRemove?: boolean, optimized?: boolean) => void;
 type RemoveFn = (vnode: VNode) => void;
 type MountComponentFn = (initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
+type UnmountComponentFn = (instance: ComponentInternalInstance, parentSuspense: SuspenseBoundary | null, doRemove?: boolean) => void;
 type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, namespace: ElementNamespace, optimized: boolean) => void;
 declare enum MoveType {
     ENTER = 0,
@@ -723,7 +739,7 @@ export declare const KeepAlive: {
 export declare function onActivated(hook: Function, target?: ComponentInternalInstance | null): void;
 export declare function onDeactivated(hook: Function, target?: ComponentInternalInstance | null): void;
 
-type CreateHook<T = any> = (hook: T, target?: ComponentInternalInstance | null) => void;
+type CreateHook<T = any> = (hook: T, target?: GenericComponentInstance | null) => void;
 export declare const onBeforeMount: CreateHook;
 export declare const onMounted: CreateHook;
 export declare const onBeforeUpdate: CreateHook;
@@ -735,7 +751,7 @@ type DebuggerHook = (e: DebuggerEvent) => void;
 export declare const onRenderTriggered: CreateHook<DebuggerHook>;
 export declare const onRenderTracked: CreateHook<DebuggerHook>;
 type ErrorCapturedHook<TError = unknown> = (err: TError, instance: ComponentPublicInstance | null, info: string) => boolean | void;
-export declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: ComponentInternalInstance | null): void;
+export declare function onErrorCaptured<TError = Error>(hook: ErrorCapturedHook<TError>, target?: GenericComponentInstance | null): void;
 
 declare enum DeprecationTypes$1 {
     GLOBAL_MOUNT = "GLOBAL_MOUNT",
@@ -1017,6 +1033,7 @@ export declare function defineComponent<TypeProps, RuntimePropsOptions extends C
 InjectOptions, InjectKeys, Slots, LocalComponents, Directives, Exposed, Provide> & ThisType<CreateComponentPublicInstanceWithMixins<ToResolvedProps<InferredProps, ResolvedEmits>, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, {}, {}, false, InjectOptions, Slots, LocalComponents, Directives, Exposed>>): DefineComponent<InferredProps, SetupBindings, Data, Computed, Methods, Mixin, Extends, ResolvedEmits, RuntimeEmitsKeys, PublicProps, ToResolvedProps<InferredProps, ResolvedEmits>, ExtractDefaultPropTypes<RuntimePropsOptions>, Slots, LocalComponents, Directives, Exposed, Provide, unknown extends TypeProps ? true : false, TypeRefs, TypeEl>;
 
 export interface App<HostElement = any> {
+    vapor?: boolean;
     version: string;
     config: AppConfig;
     use<Options extends unknown[]>(plugin: Plugin<Options>, ...options: NoInfer<Options>): this;
@@ -1050,11 +1067,11 @@ export interface App<HostElement = any> {
      */
     runWithContext<T>(fn: () => T): T;
     _uid: number;
-    _component: ConcreteComponent;
+    _component: GenericComponent;
     _props: Data | null;
     _container: HostElement | null;
     _context: AppContext;
-    _instance: ComponentInternalInstance | null;
+    _instance: GenericComponentInstance | null;
     /**
      * v2 compat only
      */
@@ -1062,27 +1079,13 @@ export interface App<HostElement = any> {
     filter?(name: string, filter: Function): this;
 }
 export type OptionMergeFunction = (to: unknown, from: unknown) => any;
-export interface AppConfig {
-    readonly isNativeTag: (tag: string) => boolean;
-    performance: boolean;
-    optionMergeStrategies: Record<string, OptionMergeFunction>;
-    globalProperties: ComponentCustomProperties & Record<string, any>;
+/**
+ * Shared app config between vdom and vapor
+ */
+interface GenericAppConfig {
+    performance?: boolean;
     errorHandler?: (err: unknown, instance: ComponentPublicInstance | null, info: string) => void;
     warnHandler?: (msg: string, instance: ComponentPublicInstance | null, trace: string) => void;
-    /**
-     * Options to pass to `@vue/compiler-dom`.
-     * Only supported in runtime compiler build.
-     */
-    compilerOptions: RuntimeCompilerOptions;
-    /**
-     * @deprecated use config.compilerOptions.isCustomElement
-     */
-    isCustomElement?: (tag: string) => boolean;
-    /**
-     * TODO document for 3.5
-     * Enable warnings for computed getters that recursively trigger itself.
-     */
-    warnRecursiveComputed?: boolean;
     /**
      * Whether to throw unhandled errors in production.
      * Default is `false` to avoid crashing on any error (and only logs it)
@@ -1094,13 +1097,35 @@ export interface AppConfig {
      */
     idPrefix?: string;
 }
-export interface AppContext {
+export interface AppConfig extends GenericAppConfig {
+    readonly isNativeTag: (tag: string) => boolean;
+    optionMergeStrategies: Record<string, OptionMergeFunction>;
+    globalProperties: ComponentCustomProperties & Record<string, any>;
+    /**
+     * Options to pass to `@vue/compiler-dom`.
+     * Only supported in runtime compiler build.
+     */
+    compilerOptions: RuntimeCompilerOptions;
+    /**
+     * @deprecated use config.compilerOptions.isCustomElement
+     */
+    isCustomElement?: (tag: string) => boolean;
+}
+/**
+ * Minimal app context shared between vdom and vapor
+ */
+export interface GenericAppContext {
     app: App;
+    config: GenericAppConfig;
+    provides: Record<string | symbol, any>;
+    components?: Record<string, Component>;
+    directives?: Record<string, Directive>;
+}
+export interface AppContext extends GenericAppContext {
     config: AppConfig;
-    mixins: ComponentOptions[];
     components: Record<string, Component>;
     directives: Record<string, Directive>;
-    provides: Record<string | symbol, any>;
+    mixins: ComponentOptions[];
 }
 type PluginInstallFunction<Options = any[]> = Options extends unknown[] ? (app: App, ...options: Options) => any : (app: App, options: Options) => any;
 export type ObjectPlugin<Options = any[]> = {
@@ -1108,7 +1133,7 @@ export type ObjectPlugin<Options = any[]> = {
 };
 export type FunctionPlugin<Options = any[]> = PluginInstallFunction<Options> & Partial<ObjectPlugin<Options>>;
 export type Plugin<Options = any[], P extends unknown[] = Options extends unknown[] ? Options : [Options]> = FunctionPlugin<P> | ObjectPlugin<P>;
-export type CreateAppFunction<HostElement> = (rootComponent: Component, rootProps?: Data | null) => App<HostElement>;
+export type CreateAppFunction<HostElement, Comp = Component> = (rootComponent: Comp, rootProps?: Data | null) => App<HostElement>;
 
 type TeleportVNode = VNode<RendererNode, RendererElement, TeleportProps>;
 export interface TeleportProps {
@@ -1129,7 +1154,7 @@ declare enum TeleportMoveTypes {
     TOGGLE = 1,// enable / disable
     REORDER = 2
 }
-declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, moveType?: TeleportMoveTypes): void;
+declare function moveTeleport(vnode: VNode, container: RendererElement, parentAnchor: RendererNode | null, { o: { insert }, m: move }: RendererInternals, parentComponent: ComponentInternalInstance | null, moveType?: TeleportMoveTypes): void;
 declare function hydrateTeleport(node: Node, vnode: TeleportVNode, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean, { o: { nextSibling, parentNode, querySelector, insert, createText }, }: RendererInternals<Node, Element>, hydrateChildren: (node: Node | null, vnode: VNode, container: Element, parentComponent: ComponentInternalInstance | null, parentSuspense: SuspenseBoundary | null, slotScopeIds: string[] | null, optimized: boolean) => Node | null): Node | null;
 export declare const Teleport: {
     __isTeleport: true;
@@ -1164,7 +1189,8 @@ export declare const Fragment: {
 export declare const Text: unique symbol;
 export declare const Comment: unique symbol;
 export declare const Static: unique symbol;
-export type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl;
+declare const VaporSlot: unique symbol;
+export type VNodeTypes = string | VNode | Component | typeof Text | typeof Static | typeof Comment | typeof Fragment | typeof Teleport | typeof TeleportImpl | typeof Suspense | typeof SuspenseImpl | typeof VaporSlot;
 export type VNodeRef = string | Ref | ((ref: Element | ComponentPublicInstance | null, refs: Record<string, any>) => void);
 type VNodeNormalizedRefAtom = {
     /**
@@ -1304,6 +1330,8 @@ export declare function createStaticVNode(content: string, numberOfNodes: number
 export declare function createCommentVNode(text?: string, asBlock?: boolean): VNode;
 export declare function mergeProps(...args: (Data & VNodeProps)[]): Data;
 
+export declare const getCurrentInstance: () => ComponentInternalInstance | null;
+
 type Data = Record<string, unknown>;
 /**
  * Public utility type for extracting the instance type of a component.
@@ -1372,7 +1400,11 @@ export interface AllowedComponentProps {
     class?: unknown;
     style?: unknown;
 }
-interface ComponentInternalOptions {
+export interface ComponentInternalOptions {
+    /**
+     * indicates vapor component
+     */
+    __vapor?: boolean;
     /**
      * Compat build only, for bailing out of certain compatibility behavior
      */
@@ -1399,6 +1431,14 @@ interface ClassComponent {
     new (...args: any[]): ComponentPublicInstance<any, any, any, any, any>;
     __vccOpts: ComponentOptions;
 }
+/**
+ * Type used where a function accepts both vdom and vapor components.
+ */
+type GenericComponent = ({
+    name?: string;
+} | ((() => any) & {
+    displayName?: string;
+})) & ComponentInternalOptions;
 /**
  * Concrete component type matches its actual value: it's either an options
  * object, or a function. Use this where the code expects to work with actual
@@ -1412,21 +1452,55 @@ export type ConcreteComponent<Props = {}, RawBindings = any, D = any, C extends
  */
 export type Component<PropsOrInstance = any, RawBindings = any, D = any, C extends ComputedOptions = ComputedOptions, M extends MethodOptions = MethodOptions, E extends EmitsOptions | Record<string, any[]> = {}, S extends Record<string, any> = any> = ConcreteComponent<PropsOrInstance, RawBindings, D, C, M, E, S> | ComponentPublicInstanceConstructor<PropsOrInstance>;
 
+export type LifecycleHook<TFn = Function> = (TFn & SchedulerJob)[] | null;
 export type SetupContext<E = EmitsOptions, S extends SlotsType = {}> = E extends any ? {
     attrs: Data;
     slots: UnwrapSlotsType<S>;
     emit: EmitFn<E>;
     expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
 } : never;
+/**
+ * Base component instance interface that is shared between vdom mode and vapor
+ * mode, so that we can have a mixed instance tree and reuse core logic that
+ * operate on both.
+ */
+export interface GenericComponentInstance {
+    vapor?: boolean;
+    uid: number;
+    type: GenericComponent;
+    root: GenericComponentInstance | null;
+    parent: GenericComponentInstance | null;
+    appContext: GenericAppContext;
+    /**
+     * render function will have different types between vdom and vapor
+     */
+    render?: Function | null;
+    props: Data;
+    attrs: Data;
+    refs: Data;
+    emit: EmitFn;
+    exposed: Record<string, any> | null;
+    exposeProxy: Record<string, any> | null;
+    isMounted: boolean;
+    isUnmounted: boolean;
+    isDeactivated: boolean;
+    /**
+     * Public instance proxy, vdom only
+     */
+    proxy?: any;
+    vnode?: VNode;
+    subTree?: VNode;
+}
 /**
  * We expose a subset of properties on the internal instance as they are
  * useful for advanced external libraries and tools.
  */
-export interface ComponentInternalInstance {
+export interface ComponentInternalInstance extends GenericComponentInstance {
+    vapor?: never;
     uid: number;
     type: ConcreteComponent;
-    parent: ComponentInternalInstance | null;
-    root: ComponentInternalInstance;
+    parent: GenericComponentInstance | null;
+    root: GenericComponentInstance;
     appContext: AppContext;
     /**
      * Vnode representing this component in its parent's vdom tree
@@ -1449,19 +1523,11 @@ export interface ComponentInternalInstance {
      */
     job: SchedulerJob;
     proxy: ComponentPublicInstance | null;
-    exposed: Record<string, any> | null;
-    exposeProxy: Record<string, any> | null;
     data: Data;
-    props: Data;
-    attrs: Data;
-    slots: InternalSlots;
-    refs: Data;
     emit: EmitFn;
-    isMounted: boolean;
-    isUnmounted: boolean;
-    isDeactivated: boolean;
+    slots: InternalSlots;
+    exposeProxy: Record<string, any> | null;
 }
-export declare const getCurrentInstance: () => ComponentInternalInstance | null;
 /**
  * For runtime-dom to register the compiler.
  * Note the exported method uses any to avoid d.ts relying on the compiler types.
@@ -1530,7 +1596,7 @@ export declare function defineAsyncComponent<T extends Component = {
 export declare function useModel<M extends PropertyKey, T extends Record<string, any>, K extends keyof T, G = T[K], S = T[K]>(props: T, name: K, options?: DefineModelOptions<T[K], G, S>): ModelRef<T[K], M, G, S>;
 
 export type TemplateRef<T = unknown> = Readonly<ShallowRef<T | null>>;
-export declare function useTemplateRef<T = unknown, Keys extends string = string>(key: Keys): TemplateRef<T>;
+export declare function useTemplateRef<T = unknown, Keys extends string = string>(key: Keys): Readonly<ShallowRef<T | null>>;
 
 export declare function useId(): string;
 
@@ -1596,9 +1662,9 @@ export declare enum ErrorCodes {
     APP_UNMOUNT_CLEANUP = 16
 }
 type ErrorTypes = LifecycleHooks | ErrorCodes | WatchErrorCodes;
-export declare function callWithErrorHandling(fn: Function, instance: ComponentInternalInstance | null | undefined, type: ErrorTypes, args?: unknown[]): any;
-export declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: ComponentInternalInstance | null, type: ErrorTypes, args?: unknown[]): any;
-export declare function handleError(err: unknown, instance: ComponentInternalInstance | null | undefined, type: ErrorTypes, throwInDev?: boolean): void;
+export declare function callWithErrorHandling(fn: Function, instance: GenericComponentInstance | null | undefined, type: ErrorTypes, args?: unknown[]): any;
+export declare function callWithAsyncErrorHandling(fn: Function | Function[], instance: GenericComponentInstance | null, type: ErrorTypes, args?: unknown[]): any;
+export declare function handleError(err: unknown, instance: GenericComponentInstance | null | undefined, type: ErrorTypes, throwInDev?: boolean): void;
 
 export declare function initCustomFormatter(): void;