@vue/runtime-core 3.1.0 → 3.1.4

package/dist/runtime-core.d.ts

@@ -63,6 +63,7 @@ export declare interface App<HostElement = any> {
     _props: Data | null;
     _container: HostElement | null;
     _context: AppContext;
+    _instance: ComponentInternalInstance | null;
     /**
      * v2 compat only
      */
@@ -329,6 +330,7 @@ export declare interface ComponentInternalInstance {
     /* Excluded from this release type: inheritAttrs */
     proxy: ComponentPublicInstance | null;
     exposed: Record<string, any> | null;
+    exposeProxy: Record<string, any> | null;
     /* Excluded from this release type: withProxy */
     /* Excluded from this release type: ctx */
     data: Data;
@@ -503,7 +505,7 @@ declare function createCompatVue(createApp: CreateAppFunction<Element>, createSi
 
 declare function createComponentInstance(vnode: VNode, parent: ComponentInternalInstance | null, suspense: SuspenseBoundary | null): ComponentInternalInstance;
 
-declare type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults>>;
+export declare type CreateComponentPublicInstance<P = {}, B = {}, D = {}, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = {}, PublicProps = P, Defaults = {}, MakeDefaultsOptional extends boolean = false, PublicMixin = IntersectionMixin<Mixin> & IntersectionMixin<Extends>, PublicP = UnwrapMixinsType<PublicMixin, 'P'> & EnsureNonVoid<P>, PublicB = UnwrapMixinsType<PublicMixin, 'B'> & EnsureNonVoid<B>, PublicD = UnwrapMixinsType<PublicMixin, 'D'> & EnsureNonVoid<D>, PublicC extends ComputedOptions = UnwrapMixinsType<PublicMixin, 'C'> & EnsureNonVoid<C>, PublicM extends MethodOptions = UnwrapMixinsType<PublicMixin, 'M'> & EnsureNonVoid<M>, PublicDefaults = UnwrapMixinsType<PublicMixin, 'Defaults'> & EnsureNonVoid<Defaults>> = ComponentPublicInstance<PublicP, PublicB, PublicD, PublicC, PublicM, E, PublicProps, PublicDefaults, MakeDefaultsOptional, ComponentOptionsBase<P, B, D, C, M, Mixin, Extends, E, string, Defaults>>;
 
 export declare function createHydrationRenderer(options: RendererOptions<Node, Element>): HydrationRenderer;
 
@@ -584,18 +586,91 @@ export declare function defineComponent<PropNames extends string, RawBindings, D
 
 export declare function defineComponent<PropsOptions extends Readonly<ComponentPropsOptions>, RawBindings, D, C extends ComputedOptions = {}, M extends MethodOptions = {}, Mixin extends ComponentOptionsMixin = ComponentOptionsMixin, Extends extends ComponentOptionsMixin = ComponentOptionsMixin, E extends EmitsOptions = Record<string, any>, EE extends string = string>(options: ComponentOptionsWithObjectProps<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>): DefineComponent<PropsOptions, RawBindings, D, C, M, Mixin, Extends, E, EE>;
 
-export declare function defineEmit<TypeEmit = undefined, E extends EmitsOptions = EmitsOptions, EE extends string = string, InferredEmit = EmitFn<E>>(emitOptions?: E | EE[]): TypeEmit extends undefined ? InferredEmit : TypeEmit;
+/**
+ * @deprecated use `defineEmits` instead.
+ */
+export declare const defineEmit: typeof defineEmits;
+
+/**
+ * Vue `<script setup>` compiler macro for declaring a component's emitted
+ * events. The expected argument is the same as the component `emits` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * const emit = defineEmits(['change', 'update'])
+ * ```
+ *
+ * Example type-based decalration:
+ * ```ts
+ * const emit = defineEmits<{
+ *   (event: 'change'): void
+ *   (event: 'update', id: number): void
+ * }>()
+ *
+ * emit('change')
+ * emit('update', 1)
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+export declare function defineEmits<EE extends string = string>(emitOptions: EE[]): EmitFn<EE[]>;
+
+export declare function defineEmits<E extends EmitsOptions = EmitsOptions>(emitOptions: E): EmitFn<E>;
+
+export declare function defineEmits<TypeEmit>(): TypeEmit;
 
 /**
- * Compile-time-only helper used for declaring props inside `<script setup>`.
- * This is stripped away in the compiled code and should never be actually
- * called at runtime.
+ * Vue `<script setup>` compiler macro for declaring a component's exposed
+ * instance properties when it is accessed by a parent component via template
+ * refs.
+ *
+ * `<script setup>` components are closed by default - i.e. varaibles inside
+ * the `<script setup>` scope is not exposed to parent unless explicitly exposed
+ * via `defineExpose`.
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
+ */
+export declare function defineExpose(exposed?: Record<string, any>): void;
+
+/**
+ * Vue `<script setup>` compiler macro for declaring component props. The
+ * expected argument is the same as the component `props` option.
+ *
+ * Example runtime declaration:
+ * ```js
+ * // using Array syntax
+ * const props = defineProps(['foo', 'bar'])
+ * // using Object syntax
+ * const props = defineProps({
+ *   foo: String,
+ *   bar: {
+ *     type: Number,
+ *     required: true
+ *   }
+ * })
+ * ```
+ *
+ * Equivalent type-based decalration:
+ * ```ts
+ * // will be compiled into equivalent runtime declarations
+ * const props = defineProps<{
+ *   foo?: string
+ *   bar: number
+ * }>()
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the
+ * output and should **not** be actually called at runtime.
  */
-export declare function defineProps<TypeProps = undefined, PropNames extends string = string, InferredProps = {
+export declare function defineProps<PropNames extends string = string>(props: PropNames[]): Readonly<{
     [key in PropNames]?: any;
-}>(props?: PropNames[]): Readonly<TypeProps extends undefined ? InferredProps : TypeProps>;
+}>;
+
+export declare function defineProps<PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions>(props: PP): Readonly<ExtractPropTypes<PP>>;
 
-export declare function defineProps<TypeProps = undefined, PP extends ComponentObjectPropsOptions = ComponentObjectPropsOptions, InferredProps = ExtractPropTypes<PP>>(props?: PP): Readonly<TypeProps extends undefined ? InferredProps : TypeProps>;
+export declare function defineProps<TypeProps>(): Readonly<TypeProps>;
 
 export declare const enum DeprecationTypes {
     GLOBAL_MOUNT = "GLOBAL_MOUNT",
@@ -717,6 +792,9 @@ declare type ExtractMixin<T> = {
 declare type ExtractOptionProp<T> = T extends ComponentOptionsBase<infer P, any, any, any, any, any, any, any> ? unknown extends P ? {} : P : {};
 
 export declare type ExtractPropTypes<O> = O extends object ? {
+    [K in keyof O]?: unknown;
+} & // This is needed to keep the relation between the option prop and the props, allowing to use ctrl+click to navigate to the prop options. see: #3656
+{
     [K in RequiredKeys<O>]: InferPropType<O[K]>;
 } & {
     [K in OptionalKeys<O>]?: InferPropType<O[K]>;
@@ -799,6 +877,10 @@ export declare interface HydrationRenderer extends Renderer<Element> {
     hydrate: RootHydrateFunction;
 }
 
+declare type InferDefaults<T> = {
+    [K in keyof T]?: NotUndefined<T[K]> extends (number | string | boolean | symbol | Function) ? NotUndefined<T[K]> : (props: T) => NotUndefined<T[K]>;
+};
+
 declare type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
     type: null | true;
 }] ? any : [T] extends [ObjectConstructor | {
@@ -994,6 +1076,8 @@ declare type MergedComponentOptionsOverride = {
     errorCaptured?: MergedHook<ErrorCapturedHook>;
 };
 
+/* Excluded from this release type: mergeDefaults */
+
 declare type MergedHook<T = (() => void)> = T | T[];
 
 export declare function mergeProps(...args: (Data & VNodeProps)[]): Data & VNodeProps;
@@ -1037,6 +1121,8 @@ declare function normalizeSuspenseChildren(vnode: VNode): void;
 
 declare function normalizeVNode(child: VNodeChild): VNode;
 
+declare type NotUndefined<T> = T extends undefined ? never : T;
+
 declare const NULL_DYNAMIC_COMPONENT: unique symbol;
 
 export declare interface ObjectDirective<T = any, V = any> {
@@ -1162,6 +1248,10 @@ declare interface PropOptions<T = any, D = T> {
     validator?(value: unknown): boolean;
 }
 
+declare type PropsWithDefaults<Base, Defaults> = Base & {
+    [K in keyof Defaults]: K extends keyof Base ? NotUndefined<Base[K]> : never;
+};
+
 export declare type PropType<T> = PropConstructor<T> | PropConstructor<T>[];
 
 export declare function provide<T>(key: InjectionKey<T> | string | number, value: T): void;
@@ -1251,7 +1341,7 @@ export declare interface RendererOptions<HostNode = RendererNode, HostElement =
     querySelector?(selector: string): HostElement | null;
     setScopeId?(el: HostElement, id: string): void;
     cloneNode?(node: HostNode): HostNode;
-    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, isSVG: boolean): HostElement[];
+    insertStaticContent?(content: string, parent: HostElement, anchor: HostNode | null, isSVG: boolean, cached?: HostNode[] | null): HostElement[];
 }
 
 export declare type RenderFunction = () => VNodeChild;
@@ -1383,7 +1473,7 @@ export declare interface SetupContext<E = EmitsOptions> {
     attrs: Data;
     slots: Slots;
     emit: EmitFn<E>;
-    expose: (exposed: Record<string, any>) => void;
+    expose: (exposed?: Record<string, any>) => void;
 }
 
 declare type SetupRenderEffectFn = (instance: ComponentInternalInstance, initialVNode: VNode, container: RendererElement, anchor: RendererNode | null, parentSuspense: SuspenseBoundary | null, isSVG: boolean, optimized: boolean) => void;
@@ -1541,8 +1631,15 @@ export { unref }
 declare type UnwrapMixinsType<T, Type extends OptionTypesKeys> = T extends OptionTypesType ? T[Type] : never;
 export { UnwrapRef }
 
+export declare function useAttrs(): SetupContext['attrs'];
+
+/**
+ * @deprecated use `useSlots` and `useAttrs` instead.
+ */
 export declare function useContext(): SetupContext;
 
+export declare function useSlots(): SetupContext['slots'];
+
 export declare const useSSRContext: <T = Record<string, any>>() => T | undefined;
 
 export declare function useTransitionState(): TransitionState;
@@ -1579,7 +1676,8 @@ export declare interface VNode<HostNode = RendererNode, HostElement = RendererEl
     anchor: HostNode | null;
     target: HostElement | null;
     targetAnchor: HostNode | null;
-    staticCount: number;
+    staticCount?: number;
+    staticCache?: HostNode[];
     suspense: SuspenseBoundary | null;
     ssContent: VNode | null;
     ssFallback: VNode | null;
@@ -1662,12 +1760,38 @@ export declare type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T);
 
 export declare type WatchStopHandle = () => void;
 
+/**
+ * Runtime helper for storing and resuming current instance context in
+ * async setup().
+ */
+export declare function withAsyncContext<T>(awaitable: T | Promise<T>): Promise<T>;
+
 /**
  * Wrap a slot function to memoize current rendering instance
  * @private compiler helper
  */
 export declare function withCtx(fn: Function, ctx?: ComponentInternalInstance | null, isNonScopedSlot?: boolean): Function;
 
+/**
+ * Vue `<script setup>` compiler macro for providing props default values when
+ * using type-based `defineProps` decalration.
+ *
+ * Example usage:
+ * ```ts
+ * withDefaults(defineProps<{
+ *   size?: number
+ *   labels?: string[]
+ * }>(), {
+ *   size: 3,
+ *   labels: () => ['default label']
+ * })
+ * ```
+ *
+ * This is only usable inside `<script setup>`, is compiled away in the output
+ * and should **not** be actually called at runtime.
+ */
+export declare function withDefaults<Props, Defaults extends InferDefaults<Props>>(props: Props, defaults: Defaults): PropsWithDefaults<Props, Defaults>;
+
 /**
  * Adds directives to a VNode.
  */
@@ -1697,3 +1821,17 @@ declare module '@vue/reactivity' {
         }
   }
 }
+
+// Note: this file is auto concatenated to the end of the bundled d.ts during
+// build.
+type _defineProps = typeof defineProps
+type _defineEmits = typeof defineEmits
+type _defineExpose = typeof defineExpose
+type _withDefaults = typeof withDefaults
+
+declare global {
+  const defineProps: _defineProps
+  const defineEmits: _defineEmits
+  const defineExpose: _defineExpose
+  const withDefaults: _withDefaults
+}