vize 0.608.0 → 0.609.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/generated/content-mapper-types.d.ts +9 -21
- package/package.json +4 -2
- package/virtual-ts-globals.d.ts +489 -0
- package/virtual-ts-patterns.d.ts +311 -0
- package/virtual-ts.d.cts +456 -504
- package/virtual-ts.d.mts +456 -504
- package/virtual-ts.d.ts +456 -504
package/virtual-ts.d.ts
CHANGED
|
@@ -1,522 +1,474 @@
|
|
|
1
|
+
import type {} from "./virtual-ts-globals.js" with { "resolution-mode": "import" };
|
|
2
|
+
import type {} from "./virtual-ts-patterns.js" with { "resolution-mode": "import" };
|
|
1
3
|
// Generated from the shared virtual TypeScript helpers. Do not edit.
|
|
2
4
|
// One module for every content-mapper virtual file.
|
|
3
|
-
|
|
4
|
-
//
|
|
5
|
-
//
|
|
6
|
-
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
// preamble previously embedded in every generated .vue.ts module.
|
|
10
|
-
|
|
11
|
-
// ImportMeta augmentation (reference existing framework types)
|
|
12
|
-
// Extend ImportMeta with Nuxt-specific properties not covered by vite/client
|
|
13
|
-
interface ImportMeta {
|
|
14
|
-
client: boolean;
|
|
15
|
-
server: boolean;
|
|
16
|
-
dev: boolean;
|
|
17
|
-
prod: boolean;
|
|
18
|
-
ssr: boolean;
|
|
19
|
-
}
|
|
20
|
-
|
|
21
|
-
namespace JSX { interface IntrinsicAttributes { class?: unknown; style?: unknown; } }
|
|
22
|
-
// vue-tsc generic library components accept unknown attrs through this
|
|
23
|
-
// fallback, which vue-tsc itself declares unless `checkUnknownProps` is set.
|
|
24
|
-
var __VLS_PROPS_FALLBACK: Record<string, unknown>;
|
|
25
|
-
|
|
26
|
-
// Shared type helpers used by generated virtual modules
|
|
27
|
-
type __EmitShape<T> = T extends (...args: any[]) => any ? T : T extends Record<string, any> ? { [K in keyof T]: T[K] extends (...args: infer A) => any ? A : T[K] extends any[] ? T[K] : any[]; } : Record<string, any[]>;
|
|
28
|
-
type __EmitArgs<T, K extends keyof T> = T[K] extends any[] ? T[K] : any[];
|
|
29
|
-
type __EmitFn<T, __S = __EmitShape<T>, __K extends keyof __S & string = keyof __S & string, __U = { [K in __K]: (event: K, ...args: __EmitArgs<__S, K>) => void }[__K]> = __S extends (...args: any[]) => any ? __S : [__K] extends [never] ? (event: never, ...args: any[]) => void : (__U extends unknown ? (fn: __U) => void : never) extends (fn: infer __I) => void ? __I : never;
|
|
30
|
-
type __RuntimePropValue<T> = T extends abstract new (...args: any[]) => infer V ? V : T extends (...args: any[]) => infer V ? V : never;
|
|
31
|
-
type __RuntimePropCtorInner<T> = T extends null | undefined ? never : T extends readonly (infer U)[] ? __RuntimePropCtorInner<U> : T extends { type: infer U } ? __RuntimePropCtorInner<U> : T extends StringConstructor ? string : T extends NumberConstructor ? number : T extends BooleanConstructor ? boolean : T extends ArrayConstructor ? unknown[] : T extends ObjectConstructor ? Record<string, any> : T extends DateConstructor ? Date : T extends FunctionConstructor ? (...args: any[]) => any : __RuntimePropValue<T>;
|
|
32
|
-
type __RuntimePropCtor<T> = [__RuntimePropCtorInner<T>] extends [never] ? unknown : __RuntimePropCtorInner<T>;
|
|
33
|
-
type __RuntimePropHasBoolean<T> = T extends BooleanConstructor ? true : T extends readonly (infer U)[] ? __RuntimePropHasBoolean<U> : T extends { type: infer U } ? __RuntimePropHasBoolean<U> : false;
|
|
34
|
-
type __RuntimePropResolved<T> = T extends { required: true } ? true : T extends { default: any } ? true : __RuntimePropHasBoolean<T>;
|
|
35
|
-
type __RuntimePropShape<T extends Record<string, any>> = { [K in keyof T]: __RuntimePropResolved<T[K]> extends true ? __RuntimePropCtor<T[K]> : __RuntimePropCtor<T[K]> | undefined; };
|
|
36
|
-
type $IsAny<T> = 0 extends (1 & T) ? true : false;
|
|
37
|
-
type __LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
|
|
38
|
-
type $BooleanKey<T, K extends keyof T = keyof T> = K extends any ? [Exclude<T[K], undefined>] extends [never] ? never : [Exclude<T[K], undefined>] extends [boolean] ? K : never : never; type __DefineProps<T, __BKeys extends keyof T = $BooleanKey<T>> = Readonly<T> & { readonly [K in __BKeys]-?: boolean };
|
|
39
|
-
type $IfAny<T, Y, N> = 0 extends (1 & T) ? Y : N;
|
|
40
|
-
type $NotUndefined<T> = T extends undefined ? never : T;
|
|
41
|
-
type $MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
|
|
42
|
-
type $DefaultNativeType = null | number | string | boolean | symbol | Function;
|
|
43
|
-
type $InferDefault<P, T> = ((props: P) => T & {}) | (T extends $DefaultNativeType ? T : never);
|
|
44
|
-
type __WithDefaultsArgs<T> = { [K in keyof T]?: $InferDefault<T, T[K]> };
|
|
45
|
-
type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unknown ? Readonly<$MappedOmit<T, keyof D>> & { readonly [K in keyof D as K extends keyof T ? K : never]-?: K extends keyof T ? D[K] extends undefined ? $IfAny<D[K], $NotUndefined<T[K]>, T[K]> : $NotUndefined<T[K]> : never } & { readonly [K in __BKeys]-?: K extends keyof D ? D[K] extends undefined ? boolean | undefined : boolean : boolean } : never;
|
|
46
|
-
type __Ref<T> = import('vue').Ref<T>;
|
|
47
|
-
type __ShallowRef<T> = import('vue').ShallowRef<T>;
|
|
48
|
-
type $KebabCase<S extends string, Acc extends string = ""> = S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? $KebabCase<Tail, `${Acc}${Head}`> : $KebabCase<Tail, `${Acc}-${Lowercase<Head>}`> : `${Acc}${S}`;
|
|
49
|
-
type $KebabProps<T> = { [K in keyof T & string as $KebabCase<K>]: T[K] };type $RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
|
|
50
|
-
type $DomListenerProps = { [K in keyof GlobalEventHandlersEventMap as K extends string ? `on${Capitalize<K>}` : never]?: (event: GlobalEventHandlersEventMap[K]) => void };
|
|
51
|
-
type $FallthroughAttrs<Owned = {}> = { class?: unknown; style?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown } & { [K in `aria-${string}` | `aria${Capitalize<string>}`]?: unknown } & Omit<$DomListenerProps, keyof Owned>;
|
|
52
|
-
// Match Vue's public prop contract, including runtime-core module augmentations.
|
|
53
|
-
type $PublicComponentInputProps = import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
|
|
54
|
-
type $ComponentMetadataKeys<T> = $IsAny<T> extends true ? never : T extends unknown ? keyof NonNullable<T> : never;
|
|
55
|
-
type $ComponentOwnKeys<P = {}, E = {}> = keyof $PublicComponentInputProps | $ComponentMetadataKeys<P> | $ComponentMetadataKeys<E>;
|
|
56
|
-
type $UnownedComponentAttrs<F, P = {}, E = {}> = $IsAny<F> extends true ? F : unknown extends F ? F : F extends unknown ? F extends null | undefined ? F : { [K in keyof F as K extends $ComponentOwnKeys<P, E> ? never : K]: F[K] } : never;
|
|
57
|
-
type $Prettify<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
|
|
58
|
-
type $ComponentFallthroughSurface<C> = (C extends { new (...args: any[]): { $props: infer __P } } ? __P : C extends (props: infer __P, ...args: any[]) => any ? __P : Record<string, unknown>) & (C extends { readonly __vizeFallthroughProps?: infer __F } ? $IsAny<__F> extends true ? {} : NonNullable<__F> : {});
|
|
59
|
-
type $ComponentFallthroughProps<C> = { [K in keyof $ComponentFallthroughSurface<C>]: $ComponentFallthroughSurface<C>[K] };
|
|
60
|
-
type $ComponentInputProps<T, Declared = {}> = T extends unknown ? Partial<T> & Partial<$KebabProps<T>> & Declared & $FallthroughAttrs<T & Declared> & $PublicComponentInputProps : never;
|
|
61
|
-
type $MissingRequiredInputKeys<T, Authored, K extends $RequiredKeys<T> & string = $RequiredKeys<T> & string> = K extends unknown ? K extends keyof Authored ? never : $KebabCase<K> extends keyof Authored ? never : K : never;
|
|
62
|
-
type $IsPropKeyUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : false;
|
|
63
|
-
type $IsSinglePropKey<T> = [T] extends [never] ? false : $IsPropKeyUnion<T> extends true ? false : true;
|
|
64
|
-
type $RelaxedDynamicUnionExtra<T, Declared, Authored, K extends keyof Authored> = [keyof Declared] extends [never] ? $IsSinglePropKey<$RequiredKeys<T>> extends true ? K extends string ? K extends `on${string}` ? false : Authored[K] extends true ? false : true : false : false : false;
|
|
65
|
-
type $ExtraInputKeys<T, Declared, Authored, Allowed, K extends keyof Authored = Exclude<keyof Authored, keyof Allowed>> = K extends unknown ? $RelaxedDynamicUnionExtra<T, Declared, Authored, K> extends true ? never : K : never;
|
|
66
|
-
type $ComponentMissingInputGuard<T, Authored> = T extends unknown ? [$MissingRequiredInputKeys<T, Authored>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: $MissingRequiredInputKeys<T, Authored>; readonly extra: never; } } : never;
|
|
67
|
-
type $ComponentInputGuardFor<T, Declared, Authored, Allowed> = [$MissingRequiredInputKeys<T, Authored> | $ExtraInputKeys<T, Declared, Authored, Allowed>] extends [never] ? {} : { readonly __vizeInvalidComponentProps: { readonly missing: $MissingRequiredInputKeys<T, Authored>; readonly extra: $ExtraInputKeys<T, Declared, Authored, Allowed>; } };
|
|
68
|
-
type $ComponentInputGuard<T, Declared, Authored> = $UsePublicInstance<Authored> extends true ? {} : T extends unknown ? $ComponentInputGuardFor<T, Declared, Authored, $ComponentInputProps<T, Declared>> : never;
|
|
69
|
-
type $ComponentInputFor<T, Declared, Authored, Allowed> = Allowed & $ComponentInputGuardFor<T, Declared, Authored, Allowed>;
|
|
70
|
-
type $ComponentInput<T, Declared, Authored> = $UsePublicInstance<Authored> extends true ? $ComponentInputProps<T, Declared> : T extends unknown ? $ComponentInputFor<T, Declared, Authored, $ComponentInputProps<T, Declared>> : never;
|
|
71
|
-
type $AuthoredKeyWitness<T> = { [K in keyof T]: unknown };
|
|
72
|
-
type $IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
|
|
73
|
-
type $UsePublicInstance<T> = $IsAny<T> extends true ? true : $IsUnknown<T>;
|
|
74
|
-
type $LiteralKeys<T> = keyof { [K in keyof T as K extends string ? string extends K ? never : K extends `$${infer R}` ? string extends R ? never : K : K : number extends K ? never : symbol extends K ? never : K]: unknown };
|
|
75
|
-
type $ReplaceComponentProps<T, P> = Omit<T, '$props'> & Pick<T, Exclude<$LiteralKeys<T>, '$props'>> & { $props: P };
|
|
76
|
-
type $PublicEmit<T, S = __EmitShape<T>, K extends keyof S & string = keyof S & string> = S extends (...args: any[]) => any ? S : [K] extends [never] ? (event: string, ...args: any[]) => void : __EmitFn<T>;
|
|
77
|
-
type $PublicSlots<T> = [keyof T] extends [never] ? import('vue').ComponentPublicInstance['$slots'] : T;
|
|
78
|
-
// @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
|
|
79
|
-
type $ComponentPublicBase = Omit<import('vue').ComponentPublicInstance, '$props' | '$emit' | '$slots'>;
|
|
80
|
-
// @ts-ignore TS2694/TS2307: a `vue` without `NativeElements` must degrade native prop checks to unchecked, never error. See virtual_ts/expressions/native_props.rs.
|
|
81
|
-
type $NativeElements = import('vue').NativeElements;
|
|
82
|
-
type $NativeElement<Tag extends PropertyKey> = Tag extends keyof $NativeElements ? $NativeElements[Tag] : unknown;
|
|
83
|
-
type $NativeElementProp<Element, Prop extends PropertyKey> = Prop extends keyof Element ? Element[Prop] : unknown;
|
|
84
|
-
function __vizeNativeElementProp<__Tag extends PropertyKey, __Prop extends PropertyKey>(value: $NativeElementProp<$NativeElement<__Tag>, __Prop>): void;
|
|
85
|
-
type $ComponentAttrCamel<S extends string> = S extends `${infer __H}-${infer __T}` ? `${__H}${Capitalize<$ComponentAttrCamel<__T>>}` : S;
|
|
86
|
-
type $ComponentNativeAttrNames = { [K in keyof $NativeElements & string]: keyof $NativeElements[K] }[keyof $NativeElements & string] & string;
|
|
87
|
-
type $ComponentGlobalHtmlAttrs = $IsAny<$NativeElements> extends true ? {} : { [K in $ComponentNativeAttrNames as K | $ComponentAttrCamel<K>]?: unknown } & { [K in `data-${string}` | `data${Capitalize<string>}`]?: unknown };
|
|
88
|
-
function __vizeComponentGlobalHtmlAttrs(value: $ComponentGlobalHtmlAttrs): void;
|
|
89
|
-
function __vForList<const T>(source: T): T extends number ? [item: number, key: number][] : T extends string ? [item: string, key: number][] : T extends readonly any[] ? (T extends readonly (infer U)[] ? [item: U, key: number] : never)[] : T extends Iterable<any> ? (T extends Iterable<infer U> ? [item: U, key: number] : never)[] : [item: T[keyof T], key: keyof T extends string ? keyof T : `${keyof T & (string | number)}`, index: number][];type $DirectiveHook<D, H = Extract<D[keyof D & ('created' | 'beforeMount' | 'mounted' | 'beforeUpdate' | 'updated' | 'beforeUnmount' | 'unmounted')], (...args: any[]) => any>> = D extends (...args: any[]) => any ? D : [H] extends [never] ? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }, ...args: any[]) => void : H;
|
|
90
|
-
type $DirectiveCall<H> = H extends (...args: any[]) => any ? Parameters<H>['length'] extends 0 | 1 ? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }) => void : H : never;
|
|
91
|
-
function __vizeDirective<D>(directive: D): $DirectiveCall<$DirectiveHook<D>>;
|
|
92
|
-
// @ts-ignore TS2694/TS2307: a `vue` without `GlobalDirectives` must degrade registered directives to unchecked, never error.
|
|
93
|
-
type $GlobalDirectives = import('vue').GlobalDirectives;
|
|
94
|
-
// @ts-ignore TS2694/TS2307: a `vue` without `Directive` must degrade registered directives to unchecked, never error.
|
|
95
|
-
type $OwnDirectives<D> = D extends infer L & Record<string, import('vue').Directive> ? L : D;
|
|
96
|
-
type $LocalDirectives<C> = C extends { directives?: infer D } ? { [K in keyof $OwnDirectives<NonNullable<D>> & string as string extends K ? never : `v${Capitalize<K>}`]: $OwnDirectives<NonNullable<D>>[K] } : {};
|
|
97
|
-
function __vizeRegisteredDirective<C, K extends string>(): K extends keyof $LocalDirectives<C> ? $LocalDirectives<C>[K] : K extends keyof $GlobalDirectives ? $GlobalDirectives[K] : unknown;
|
|
98
|
-
function __vizeVaporDirective<D>(directive: D): D extends (...args: any[]) => any ? D : (node: unknown, value?: () => unknown, argument?: unknown, modifiers?: unknown) => void;
|
|
99
|
-
const __vizeDirectiveBindingRest: { instance: null; oldValue: null; modifiers: any; dir: any };
|
|
100
|
-
function __vizeDirectiveTail<F extends (...args: any[]) => any>(hook: F): 4 extends Parameters<F>['length'] ? [never, never] : 3 extends Parameters<F>['length'] ? [never] : [];
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
// Emit-overload helpers (consumed by the per-file __EmitProps alias)
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
type $OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
|
|
109
|
-
type $OverloadUnionRecursive<TOverload, TPartialOverload = unknown, TDepth extends unknown[] = []> = TDepth['length'] extends 32 ? never : TOverload extends (...args: infer TArgs) => infer TReturn ? TPartialOverload extends TOverload ? never : $OverloadUnionRecursive<TPartialOverload & TOverload, TPartialOverload & ((...args: TArgs) => TReturn) & $OverloadProps<TOverload>, [...TDepth, unknown]> | ((...args: TArgs) => TReturn) : never;
|
|
110
|
-
type $OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<$OverloadUnionRecursive<(() => never) & TOverload>, TOverload extends () => never ? never : () => never>;
|
|
111
|
-
type $OverloadParameters<T extends (...args: any[]) => any> = Parameters<$OverloadUnion<T>>;
|
|
112
|
-
type $IsStringLiteral<T> = T extends string ? string extends T ? false : true : false;
|
|
113
|
-
type $ParametersToFns<T extends any[]> = string extends T[0] ? { [K in string]: (...args: T extends [e: any, ...args: infer P] ? P : any[]) => any } : { [K in T[0]]: $IsStringLiteral<K> extends true ? (...args: T extends [e: infer E, ...args: infer P] ? K extends E ? P : never : never) => any : never };
|
|
114
|
-
type __EmitOptions<T, S = __EmitShape<T>> = { [K in keyof S as K extends string ? K : never]: (...args: __EmitArgs<S, K>) => any } & (__EmitShape<T> extends (...args: any[]) => any ? $ParametersToFns<$OverloadParameters<__EmitShape<T>>> : {});
|
|
115
|
-
type $Camelize<S extends string> = S extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<$Camelize<Tail>>}` : S;
|
|
116
|
-
type $HandlerKey<K extends string> = `on${Capitalize<$Camelize<K>>}`;
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
// Compiler-macro signatures (aliased inside each module's __setup() scope)
|
|
122
|
-
function __vize_defineProps<_T = unknown>(): __DefineProps<__LooseRequired<_T>, Extract<$BooleanKey<_T>, keyof __LooseRequired<_T>>>;
|
|
123
|
-
function __vize_defineProps<const _T extends readonly string[]>(_props: _T): { [K in _T[number]]?: any };
|
|
124
|
-
function __vize_defineProps<const _T extends Record<string, any>>(_props: _T): __RuntimePropShape<_T>;
|
|
125
|
-
function __vize_defineEmits<_T = unknown>(): __EmitFn<_T>;
|
|
126
|
-
function __vize_defineEmits<const _T extends readonly string[]>(_events: _T): (event: _T[number], ...args: any[]) => void;
|
|
127
|
-
function __vize_defineEmits<const _T extends Record<string, any>>(_events: _T): __EmitFn<_T>;
|
|
128
|
-
function __vize_defineExpose<_T = unknown>(_exposed?: _T): void;
|
|
129
|
-
const __vize_defineModel: typeof import('vue') extends { defineModel: infer __Macro } ? __Macro : never;
|
|
130
|
-
function __vize_defineSlots<_T = unknown>(): _T;
|
|
131
|
-
function __vize_withDefaults<_T, _BKeys extends keyof _T, _D extends __WithDefaultsArgs<_T>>(_props: __DefineProps<_T, _BKeys>, _defaults: _D): __WithDefaultsResult<_T, _D, _BKeys>;
|
|
132
|
-
function __vize_useTemplateRef<_T = any>(_key: string): __ShallowRef<_T | null>;
|
|
133
|
-
// Adapted from vuejs/language-tools e68d41bfef1770f8428f92097abe959b57de62d2.
|
|
134
|
-
// MIT license; see pattern_matching.LICENSE.
|
|
135
|
-
// Kept as a checked declaration file, shared once per TypeScript program.
|
|
136
|
-
/*
|
|
137
|
-
MIT License
|
|
138
|
-
|
|
139
|
-
Copyright (c) 2021-present Johnson Chu
|
|
140
|
-
|
|
141
|
-
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
142
|
-
of this software and associated documentation files (the "Software"), to deal
|
|
143
|
-
in the Software without restriction, including without limitation the rights
|
|
144
|
-
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
145
|
-
copies of the Software, and to permit persons to whom the Software is
|
|
146
|
-
furnished to do so, subject to the following conditions:
|
|
147
|
-
|
|
148
|
-
The above copyright notice and this permission notice shall be included in all
|
|
149
|
-
copies or substantial portions of the Software.
|
|
150
|
-
|
|
151
|
-
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
152
|
-
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
153
|
-
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
154
|
-
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
155
|
-
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
156
|
-
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
157
|
-
SOFTWARE.
|
|
158
|
-
*/
|
|
159
|
-
namespace $Patterns {
|
|
160
|
-
type Reachable<T> = [T] extends [never] ? { "Unreachable v-when": never } : true;
|
|
161
|
-
/**
|
|
162
|
-
* RFC 823 pattern types. Match narrows an arm; Subtract keeps the values left
|
|
163
|
-
* for later arms. Objects split by property and arrays by head/tail, so nested
|
|
164
|
-
* unions do not need their entire Cartesian product expanded up front.
|
|
165
|
-
*/
|
|
166
|
-
type Pattern =
|
|
167
|
-
| ["any"]
|
|
168
|
-
| ["literal" | "value", unknown]
|
|
169
|
-
| ["or", Pattern[]]
|
|
170
|
-
| ["object", [PropertyKey, Pattern][]]
|
|
171
|
-
| ["array", Pattern[], boolean];
|
|
172
|
-
|
|
173
|
-
type IsAny<T> = 0 extends 1 & T ? true : false;
|
|
174
|
-
|
|
175
|
-
// Vue can unwrap unknown to {}. Keep that space conservative too.
|
|
176
|
-
type IsUnknownLike<T> = [keyof T] extends [never] ? ({} extends T ? true : false) : false;
|
|
177
|
-
|
|
178
|
-
type IsUnion<T, C = T> = T extends C ? ([C] extends [T] ? false : true) : never;
|
|
179
|
-
|
|
180
|
-
// A runtime value with a union type matches one member, so it cannot cover the whole union.
|
|
181
|
-
type IsSingleton<T> =
|
|
182
|
-
IsAny<T> extends true
|
|
183
|
-
? false
|
|
184
|
-
: true extends IsUnion<T>
|
|
185
|
-
? false
|
|
186
|
-
: T extends string | number | bigint | boolean | null | undefined
|
|
187
|
-
? string extends T
|
|
188
|
-
? false
|
|
189
|
-
: number extends T
|
|
190
|
-
? false
|
|
191
|
-
: bigint extends T
|
|
192
|
-
? false
|
|
193
|
-
: boolean extends T
|
|
194
|
-
? false
|
|
195
|
-
: true
|
|
196
|
-
: false;
|
|
197
|
-
|
|
198
|
-
type Simplify<T> = { [K in keyof T]: T[K] };
|
|
199
|
-
|
|
200
|
-
// Remove optionality before substituting V. A homomorphic -? mapping would
|
|
201
|
-
// strip undefined from V when exactOptionalPropertyTypes is disabled.
|
|
202
|
-
type PresentProperty<T, K extends keyof T, V> = {
|
|
203
|
-
[Q in keyof Required<Pick<T, K>>]: V;
|
|
204
|
-
};
|
|
205
|
-
|
|
206
|
-
// Retain the original type when refinement changes nothing, including its readonly modifiers.
|
|
207
|
-
type ReplaceProperty<T, K extends keyof T, V> = [V] extends [never]
|
|
208
|
-
? never
|
|
209
|
-
: {} extends Pick<T, K>
|
|
210
|
-
? Simplify<Omit<T, K> & PresentProperty<T, K, V>>
|
|
211
|
-
: [T[K]] extends [V]
|
|
212
|
-
? [V] extends [T[K]]
|
|
213
|
-
? T
|
|
214
|
-
: Simplify<Omit<T, K> & PresentProperty<T, K, V>>
|
|
215
|
-
: Simplify<Omit<T, K> & PresentProperty<T, K, V>>;
|
|
216
|
-
|
|
217
|
-
// Turn the pattern descriptor emitted by vMatch.ts into a positive type constraint.
|
|
218
|
-
type PatternType<P> = P extends ["any"]
|
|
219
|
-
? unknown
|
|
220
|
-
: P extends ["literal" | "value", infer V]
|
|
221
|
-
? V
|
|
222
|
-
: P extends ["or", infer A extends unknown[]]
|
|
223
|
-
? PatternType<A[number]>
|
|
224
|
-
: P extends ["object", infer A extends [PropertyKey, unknown][]]
|
|
225
|
-
? { [Q in A[number] as Q[0]]: PatternType<Q[1]> }
|
|
226
|
-
: P extends ["array", infer A extends unknown[], infer R]
|
|
227
|
-
? [...{ [I in keyof A]: PatternType<A[I]> }, ...(R extends true ? unknown[] : [])]
|
|
228
|
-
: never;
|
|
229
|
-
|
|
230
|
-
type Match<T, P extends Pattern> = MatchImpl<T, P>;
|
|
231
|
-
type Subtract<T, P extends Pattern> = SubtractImpl<T, P>;
|
|
232
|
-
|
|
233
|
-
// Narrow one union member at a time. Object patterns constrain only their listed properties.
|
|
234
|
-
type MatchImpl<T, P> = P extends ["any"]
|
|
5
|
+
// Template-ref widening. Hoisted-only, deliberately absent from the per-file
|
|
6
|
+
// preamble: a module-scope copy is dead code (TS6196) in every component whose
|
|
7
|
+
// template scope emits no __U, and only generated template scopes use it.
|
|
8
|
+
type $IsUnion<T, __U = T> = T extends unknown ? ([__U] extends [T] ? false : true) : false;
|
|
9
|
+
export type $WidenTemplateRef<T> =
|
|
10
|
+
$IsAny<T> extends true
|
|
235
11
|
? T
|
|
236
|
-
:
|
|
237
|
-
? PatternType<P>
|
|
238
|
-
: unknown extends T
|
|
239
|
-
? PatternType<P>
|
|
240
|
-
: IsUnknownLike<T> extends true
|
|
241
|
-
? T & PatternType<P>
|
|
242
|
-
: T extends unknown
|
|
243
|
-
? P extends ["literal" | "value", infer V]
|
|
244
|
-
? T & V
|
|
245
|
-
: P extends ["or", infer A extends unknown[]]
|
|
246
|
-
? MatchImpl<T, A[number]>
|
|
247
|
-
: P extends ["object", infer A extends [PropertyKey, unknown][]]
|
|
248
|
-
? T extends null | undefined
|
|
249
|
-
? never
|
|
250
|
-
: MatchObject<T, A>
|
|
251
|
-
: P extends ["array", infer A extends unknown[], infer R]
|
|
252
|
-
? T extends readonly unknown[]
|
|
253
|
-
? T extends unknown[]
|
|
254
|
-
? MatchArray<T, A, R>
|
|
255
|
-
: Readonly<MatchArray<T, A, R>>
|
|
256
|
-
: never
|
|
257
|
-
: never
|
|
258
|
-
: never;
|
|
259
|
-
|
|
260
|
-
// Presence does not remove undefined from an optional property value.
|
|
261
|
-
type RequireProperty<T, K extends keyof T> =
|
|
262
|
-
{} extends Pick<T, K> ? Simplify<Omit<T, K> & PresentProperty<T, K, T[K]>> : T;
|
|
263
|
-
|
|
264
|
-
type MatchObject<T, A> = A extends [infer H extends [PropertyKey, unknown], ...infer R]
|
|
265
|
-
? H[0] extends keyof T
|
|
266
|
-
? H[1] extends ["any"]
|
|
267
|
-
? MatchObject<RequireProperty<T, H[0]>, R>
|
|
268
|
-
: MatchObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
|
|
269
|
-
: MatchObject<T & { [K in H[0]]: PatternType<H[1]> }, R>
|
|
270
|
-
: T;
|
|
271
|
-
|
|
272
|
-
type MatchArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
|
|
273
|
-
infer H,
|
|
274
|
-
...infer Tail,
|
|
275
|
-
]
|
|
276
|
-
? T extends readonly []
|
|
277
|
-
? never
|
|
278
|
-
: T extends readonly [infer V, ...infer Rest]
|
|
279
|
-
? Prepend<MatchImpl<V, H>, MatchArray<Rest, Tail, R>>
|
|
280
|
-
: T extends readonly [(infer V)?, ...infer Rest]
|
|
281
|
-
? Prepend<MatchImpl<T[0], H>, MatchArray<Rest, Tail, R>>
|
|
282
|
-
: never
|
|
283
|
-
: R extends true
|
|
284
|
-
? T
|
|
285
|
-
: [] extends T
|
|
286
|
-
? []
|
|
287
|
-
: never;
|
|
288
|
-
|
|
289
|
-
type Prepend<H, T> = [H] extends [never]
|
|
290
|
-
? never
|
|
291
|
-
: T extends readonly unknown[]
|
|
292
|
-
? [H, ...T]
|
|
293
|
-
: never;
|
|
294
|
-
|
|
295
|
-
// Only unguarded arms call this helper. Unknown and open primitive spaces stay uncovered.
|
|
296
|
-
type SubtractImpl<T, P> = [T] extends [never]
|
|
297
|
-
? never
|
|
298
|
-
: P extends ["any"]
|
|
299
|
-
? never
|
|
300
|
-
: IsAny<T> extends true
|
|
301
|
-
? T
|
|
302
|
-
: unknown extends T
|
|
303
|
-
? T
|
|
304
|
-
: IsUnknownLike<T> extends true
|
|
305
|
-
? T
|
|
306
|
-
: string extends T
|
|
307
|
-
? T
|
|
308
|
-
: number extends T
|
|
309
|
-
? T
|
|
310
|
-
: bigint extends T
|
|
311
|
-
? T
|
|
312
|
-
: P extends ["or", infer A extends unknown[]]
|
|
313
|
-
? SubtractAlternatives<T, A>
|
|
314
|
-
: T extends unknown
|
|
315
|
-
? P extends ["literal", infer V]
|
|
316
|
-
? Exclude<T, V>
|
|
317
|
-
: P extends ["value", infer V]
|
|
318
|
-
? IsSingleton<V> extends true
|
|
319
|
-
? Exclude<T, V>
|
|
320
|
-
: T
|
|
321
|
-
: P extends ["object", infer A extends [PropertyKey, unknown][]]
|
|
322
|
-
? T extends null | undefined
|
|
323
|
-
? T
|
|
324
|
-
: SubtractObject<T, A>
|
|
325
|
-
: P extends ["array", infer A extends unknown[], infer R]
|
|
326
|
-
? T extends readonly unknown[]
|
|
327
|
-
? T extends unknown[]
|
|
328
|
-
? SubtractArray<T, A, R>
|
|
329
|
-
: Readonly<SubtractArray<T, A, R>>
|
|
330
|
-
: T
|
|
331
|
-
: T
|
|
332
|
-
: never;
|
|
333
|
-
|
|
334
|
-
type SubtractAlternatives<T, A> = A extends [infer H, ...infer R]
|
|
335
|
-
? SubtractAlternatives<SubtractImpl<T, H>, R>
|
|
336
|
-
: T;
|
|
337
|
-
|
|
338
|
-
// The remaining object space has three cases: the key is absent, its pattern fails,
|
|
339
|
-
// or its pattern matches and a later property fails.
|
|
340
|
-
type SubtractObject<T, A> = [T] extends [never]
|
|
341
|
-
? never
|
|
342
|
-
: A extends [infer H extends [PropertyKey, unknown], ...infer R]
|
|
343
|
-
? H[0] extends keyof T
|
|
344
|
-
? H[1] extends ["any"]
|
|
345
|
-
?
|
|
346
|
-
| ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
|
|
347
|
-
| SubtractObject<RequireProperty<T, H[0]>, R>
|
|
348
|
-
:
|
|
349
|
-
| ({} extends Pick<T, H[0]> ? Omit<T, H[0]> & { [K in H[0]]?: never } : never)
|
|
350
|
-
| ReplaceProperty<T, H[0], SubtractImpl<T[H[0]], H[1]>>
|
|
351
|
-
| SubtractObject<ReplaceProperty<T, H[0], MatchImpl<T[H[0]], H[1]>>, R>
|
|
352
|
-
: T
|
|
353
|
-
: never;
|
|
354
|
-
|
|
355
|
-
// Split a tuple or array into its head and tail. Exact-length patterns also leave longer arrays.
|
|
356
|
-
type SubtractArray<T extends readonly unknown[], A extends unknown[], R> = A extends [
|
|
357
|
-
infer H,
|
|
358
|
-
...infer Tail,
|
|
359
|
-
]
|
|
360
|
-
? T extends readonly []
|
|
12
|
+
: $IsUnion<T> extends true
|
|
361
13
|
? T
|
|
362
|
-
: T extends readonly [infer V, ...infer Rest]
|
|
363
|
-
? Prepend<SubtractImpl<V, H>, Rest> | Prepend<MatchImpl<V, H>, SubtractArray<Rest, Tail, R>>
|
|
364
|
-
: T extends readonly [(infer V)?, ...infer Rest]
|
|
365
|
-
?
|
|
366
|
-
| []
|
|
367
|
-
| Prepend<SubtractImpl<T[0], H>, Rest>
|
|
368
|
-
| Prepend<MatchImpl<T[0], H>, SubtractArray<Rest, Tail, R>>
|
|
369
|
-
: T
|
|
370
|
-
: R extends true
|
|
371
|
-
? never
|
|
372
|
-
: T extends readonly []
|
|
373
|
-
? never
|
|
374
|
-
: T extends readonly [unknown, ...unknown[]]
|
|
375
|
-
? T
|
|
376
|
-
: T extends readonly [(infer V)?, ...infer Rest]
|
|
377
|
-
? [T[0], ...Rest]
|
|
378
|
-
: never;
|
|
379
|
-
|
|
380
|
-
// Diagnostic examples must be valid pattern syntax. Fall back to _ when a literal needs escaping.
|
|
381
|
-
type FormatPattern<T> = T extends string
|
|
382
|
-
? string extends T
|
|
383
|
-
? "_"
|
|
384
|
-
: T extends `${string}${"'" | '"' | "\\" | "\n" | "\r"}${string}`
|
|
385
|
-
? "_"
|
|
386
|
-
: `'${T}'`
|
|
387
|
-
: T extends bigint
|
|
388
|
-
? bigint extends T
|
|
389
|
-
? "_"
|
|
390
|
-
: `${T}n`
|
|
391
|
-
: T extends number
|
|
392
|
-
? number extends T
|
|
393
|
-
? "_"
|
|
394
|
-
: `${T}`
|
|
395
|
-
: T extends boolean | null | undefined
|
|
396
|
-
? `${T}`
|
|
397
|
-
: T extends readonly unknown[]
|
|
398
|
-
? `[${FormatTuple<T>}]`
|
|
399
|
-
: "_";
|
|
400
|
-
|
|
401
|
-
type FormatTuple<T extends readonly unknown[]> = T extends readonly []
|
|
402
|
-
? ""
|
|
403
|
-
: T extends readonly [infer H, ...infer R]
|
|
404
|
-
? `${FormatPattern<H>}${R extends [] ? "" : `, ${FormatTuple<R>}`}`
|
|
405
|
-
: "...";
|
|
406
|
-
|
|
407
|
-
type MissingPatternMessage<T> =
|
|
408
|
-
IsAny<T> extends true
|
|
409
|
-
? 'Add an unguarded v-when="_" to prove coverage.'
|
|
410
14
|
: T extends string
|
|
411
15
|
? string extends T
|
|
412
|
-
?
|
|
413
|
-
: T
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
16
|
+
? string
|
|
17
|
+
: T
|
|
18
|
+
: T extends number
|
|
19
|
+
? number extends T
|
|
20
|
+
? number
|
|
21
|
+
: T
|
|
22
|
+
: T extends boolean
|
|
23
|
+
? boolean extends T
|
|
24
|
+
? boolean
|
|
25
|
+
: T
|
|
26
|
+
: T;
|
|
27
|
+
|
|
28
|
+
export type $SlotHostSlots<C> = C extends { readonly __vizeSlots?: infer __S }
|
|
29
|
+
? NonNullable<__S>
|
|
30
|
+
: C extends { new (): { $slots: infer __S } }
|
|
31
|
+
? __S
|
|
32
|
+
: C extends (props: any, context: infer __Ctx, ...args: any[]) => any
|
|
33
|
+
? NonNullable<__Ctx> extends { slots: infer __S }
|
|
34
|
+
? __S
|
|
35
|
+
: any
|
|
36
|
+
: unknown;
|
|
37
|
+
declare function __vizeFunctionalSlots<P, C, R>(
|
|
38
|
+
component: (props: P, context: C, ...args: any[]) => R,
|
|
39
|
+
): (
|
|
40
|
+
props: P,
|
|
41
|
+
) => "__ctx" extends keyof R
|
|
42
|
+
? NonNullable<R["__ctx"]> extends { slots: infer S }
|
|
43
|
+
? S
|
|
44
|
+
: any
|
|
45
|
+
: NonNullable<C> extends { slots: infer S }
|
|
46
|
+
? S
|
|
47
|
+
: any;
|
|
48
|
+
type $NativeSlotsFactory<C> = [C] extends [new (...args: any[]) => any]
|
|
49
|
+
? (component: C) => (props: any) => $SlotHostSlots<C>
|
|
50
|
+
: C extends (...args: any[]) => any
|
|
51
|
+
? typeof __vizeFunctionalSlots
|
|
52
|
+
: (component: C) => (props: any) => $SlotHostSlots<C>;
|
|
53
|
+
export type $SlotsFactory<C> =
|
|
54
|
+
$IsAny<C> extends true
|
|
55
|
+
? (component: C) => (props: any) => any
|
|
56
|
+
: [C] extends [{ __vizeResolveSlots?: infer F }]
|
|
57
|
+
? F extends (...args: any[]) => any
|
|
58
|
+
? (component: C) => F
|
|
59
|
+
: $NativeSlotsFactory<C>
|
|
60
|
+
: [C] extends [{ readonly __vizeComponentMarker: true }]
|
|
61
|
+
? (component: C) => (props: any) => $SlotHostSlots<C>
|
|
62
|
+
: $NativeSlotsFactory<C>;
|
|
63
|
+
type $HasSlotResolver<C> = C extends { __vizeResolveSlots?: infer F }
|
|
64
|
+
? F extends (...args: any[]) => any
|
|
432
65
|
? true
|
|
433
|
-
:
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
66
|
+
: false
|
|
67
|
+
: false;
|
|
68
|
+
type $DirectSlotConstructor<C> =
|
|
69
|
+
$IsAny<C> extends true
|
|
70
|
+
? never
|
|
71
|
+
: $HasSlotResolver<C> extends true
|
|
72
|
+
? never
|
|
73
|
+
: C extends { readonly __vizeComponentMarker: true }
|
|
74
|
+
? never
|
|
75
|
+
: C extends new (...args: any[]) => { $slots: any }
|
|
76
|
+
? C
|
|
77
|
+
: never;
|
|
78
|
+
export type $SlotConstructor<C> = [$DirectSlotConstructor<C>] extends [never]
|
|
79
|
+
? new (props: any, ...args: any[]) => { $slots: never }
|
|
80
|
+
: $DirectSlotConstructor<C>;
|
|
81
|
+
type $SlotConstructorArgumentLists<C> = C extends {
|
|
82
|
+
new (...args: infer A1): any;
|
|
83
|
+
new (...args: infer A2): any;
|
|
84
|
+
new (...args: infer A3): any;
|
|
85
|
+
new (...args: infer A4): any;
|
|
86
|
+
new (...args: infer A5): any;
|
|
87
|
+
new (...args: infer A6): any;
|
|
88
|
+
new (...args: infer A7): any;
|
|
89
|
+
new (...args: infer A8): any;
|
|
437
90
|
}
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
type $
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
469
|
-
|
|
470
|
-
|
|
471
|
-
|
|
472
|
-
|
|
473
|
-
|
|
474
|
-
|
|
475
|
-
|
|
476
|
-
|
|
91
|
+
? A1 | A2 | A3 | A4 | A5 | A6 | A7 | A8
|
|
92
|
+
: C extends new (...args: infer A) => any
|
|
93
|
+
? A
|
|
94
|
+
: [unknown];
|
|
95
|
+
type $SlotConstructorHasArguments<C> =
|
|
96
|
+
$SlotConstructorArgumentLists<C> extends infer A ? (A extends [] ? never : true) : never;
|
|
97
|
+
export type $SlotConstructorWithoutArguments<C> = C extends new () => any
|
|
98
|
+
? C & ([$SlotConstructorHasArguments<C>] extends [never] ? unknown : new () => { $slots: never })
|
|
99
|
+
: new () => { $slots: never };
|
|
100
|
+
export type $SlotConstructorWithArguments<C> = [$SlotConstructorHasArguments<C>] extends [never]
|
|
101
|
+
? new (props: any, ...args: any[]) => { $slots: never }
|
|
102
|
+
: C;
|
|
103
|
+
export type $SlotConstructorArgs<C> = C extends new (props: any, ...args: infer A) => any
|
|
104
|
+
? { [K in keyof A]: any }
|
|
105
|
+
: [];
|
|
106
|
+
export type $SlotConstructorInstance<C, Z, P> = [$SlotConstructorHasArguments<C>] extends [never]
|
|
107
|
+
? Z
|
|
108
|
+
: P;
|
|
109
|
+
export type $SlotHostSelector<C> = [$DirectSlotConstructor<C>] extends [never]
|
|
110
|
+
? <S>(instance: unknown, slots: S) => S
|
|
111
|
+
: <I extends { $slots: any }>(instance: I, slots: unknown) => I["$slots"];
|
|
112
|
+
|
|
113
|
+
// @ts-ignore The unchecked payload of an untyped host: an error type, never reported.
|
|
114
|
+
type $SilentAny = {}["__vizeSilentAny"];
|
|
115
|
+
type $NamedSlotPayload<S, N> = {
|
|
116
|
+
[K in keyof S & N]-?: NonNullable<S[K]> extends (props: infer P, ...args: any[]) => any
|
|
117
|
+
? P
|
|
118
|
+
: never;
|
|
119
|
+
}[keyof S & N] extends infer P
|
|
120
|
+
? [P] extends [never]
|
|
121
|
+
? any
|
|
122
|
+
: P
|
|
123
|
+
: any;
|
|
124
|
+
export type $SlotPayload<S, N> =
|
|
125
|
+
$IsAny<S> extends true
|
|
126
|
+
? $SilentAny
|
|
127
|
+
: string extends N
|
|
128
|
+
? string extends keyof S
|
|
129
|
+
? $NamedSlotPayload<S, N>
|
|
130
|
+
: any
|
|
131
|
+
: $NamedSlotPayload<S, N>;
|
|
132
|
+
|
|
133
|
+
export type __EmitProps<T> = {
|
|
134
|
+
[
|
|
135
|
+
K in keyof __EmitOptions<T> & string as $HandlerKey<K> | `on${Capitalize<K>}`
|
|
136
|
+
]?: __EmitOptions<T>[K];
|
|
137
|
+
};
|
|
138
|
+
|
|
139
|
+
type $EmitRequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
|
|
140
|
+
type $EmitRequiredFields<T> = T extends unknown ? Pick<T, $EmitRequiredKeys<T>> : never;
|
|
141
|
+
type $EmitFiniteFields<T> = { [K in keyof T as {} extends Record<K, unknown> ? never : K]: T[K] };
|
|
142
|
+
type $EmitFallthrough<F> =
|
|
143
|
+
$IsAny<F> extends true ? {} : [NonNullable<F>] extends [never] ? {} : NonNullable<F>;
|
|
144
|
+
export type $EmitOwnedKeys<C> = $ComponentOwnKeys<
|
|
145
|
+
C extends { readonly __vizeRawProps?: infer P } ? P : {},
|
|
146
|
+
C extends { readonly __vizeEmitProps?: infer E } ? E : {}
|
|
147
|
+
>;
|
|
148
|
+
type $EmitInput<P, F, O extends PropertyKey, A> = P extends unknown
|
|
149
|
+
? F extends unknown
|
|
150
|
+
? {
|
|
151
|
+
[K in keyof A]: K extends O
|
|
152
|
+
? K extends keyof P
|
|
153
|
+
? P[K]
|
|
154
|
+
: never
|
|
155
|
+
: K extends keyof F
|
|
156
|
+
? F[K]
|
|
157
|
+
: K extends keyof P
|
|
158
|
+
? P[K]
|
|
159
|
+
: unknown;
|
|
160
|
+
} & $EmitRequiredFields<P> &
|
|
161
|
+
$EmitRequiredFields<Omit<$EmitFiniteFields<F>, O>>
|
|
162
|
+
: never
|
|
163
|
+
: never;
|
|
164
|
+
declare function __vizeConstructorEmitProps<P, E>(
|
|
165
|
+
component: new (props: P, ...args: any[]) => { $emit: E },
|
|
166
|
+
): (props: P) => __EmitProps<E>;
|
|
167
|
+
type $ConstructorEmitPropsFactory<F, O extends PropertyKey> = <P, E>(
|
|
168
|
+
component: new (props: P, ...args: any[]) => { $emit: E },
|
|
169
|
+
) => <A>(props: $EmitInput<P, $EmitFallthrough<F>, O, A>) => __EmitProps<E>;
|
|
170
|
+
type $NativeEmitPropsFactory<C> = C extends new (...args: any[]) => { $emit: any }
|
|
171
|
+
? C extends { readonly __vizeComponentMarker: true }
|
|
172
|
+
? $ConstructorEmitPropsFactory<
|
|
173
|
+
C extends { readonly __vizeFallthroughProps?: infer F } ? F : {},
|
|
174
|
+
$EmitOwnedKeys<C>
|
|
175
|
+
>
|
|
176
|
+
: typeof __vizeConstructorEmitProps
|
|
177
|
+
: (component: C) => (props: any) => {};
|
|
178
|
+
export type $EmitPropsFactory<C> =
|
|
179
|
+
$IsAny<C> extends true
|
|
180
|
+
? (component: C) => (props: any) => {}
|
|
181
|
+
: C extends { __vizeResolveEmitProps?: infer F }
|
|
182
|
+
? F extends (...args: any[]) => any
|
|
183
|
+
? (component: C) => F
|
|
184
|
+
: $NativeEmitPropsFactory<C>
|
|
185
|
+
: C extends { __vizeResolveProps?: infer F }
|
|
186
|
+
? F extends (...args: any[]) => any
|
|
187
|
+
? (component: C) => F
|
|
188
|
+
: $NativeEmitPropsFactory<C>
|
|
189
|
+
: $NativeEmitPropsFactory<C>;
|
|
477
190
|
|
|
478
191
|
// Component usage helpers shared by every generated module in a batch project.
|
|
479
192
|
export type IsAny<T> = $IsAny<T>;
|
|
480
193
|
export type ComponentGlobalHtmlAttrs = $ComponentGlobalHtmlAttrs;
|
|
481
|
-
export type $ComponentNavigationProps<P> =
|
|
482
|
-
|
|
483
|
-
export type $
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
194
|
+
export type $ComponentNavigationProps<P> =
|
|
195
|
+
$IsAny<P> extends true ? Record<string, unknown> : unknown extends P ? {} : P;
|
|
196
|
+
export type $EmitListeners<C> = C extends { __vizeEmitProps?: infer __E }
|
|
197
|
+
? $IsAny<__E> extends true
|
|
198
|
+
? {}
|
|
199
|
+
: NonNullable<__E>
|
|
200
|
+
: {};
|
|
201
|
+
export type $IsGeneratedComponent<C> = C extends { readonly __vizeComponentMarker: true }
|
|
202
|
+
? true
|
|
203
|
+
: false;
|
|
204
|
+
export type $HasFallthroughProps<C> =
|
|
205
|
+
$IsGeneratedComponent<C> extends true
|
|
206
|
+
? C extends { readonly __vizeHasFallthroughProps: true }
|
|
207
|
+
? true
|
|
208
|
+
: false
|
|
209
|
+
: false;
|
|
210
|
+
export type $FallthroughProps<C> =
|
|
211
|
+
$HasFallthroughProps<C> extends true
|
|
212
|
+
? C extends { readonly __vizeFallthroughProps?: infer __F }
|
|
213
|
+
? $IsAny<__F> extends true
|
|
214
|
+
? {}
|
|
215
|
+
: NonNullable<__F>
|
|
216
|
+
: {}
|
|
217
|
+
: {};
|
|
218
|
+
export type $RequiredFallthroughProps<C, __F = $FallthroughProps<C>, __K = $RequiredKeys<__F>> = [
|
|
219
|
+
__K,
|
|
220
|
+
] extends [never]
|
|
221
|
+
? {}
|
|
222
|
+
: { [K in keyof __F as K extends __K ? K : never]: __F[K] };
|
|
487
223
|
type $ComponentCheckProps<P, T> = { readonly [K in keyof P]: P[K] } & T;
|
|
488
|
-
type $PublicProps<C> = C extends abstract new (...args: any[]) => infer __I
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
224
|
+
type $PublicProps<C> = C extends abstract new (...args: any[]) => infer __I
|
|
225
|
+
? $IsAny<__I> extends true
|
|
226
|
+
? Record<string, unknown>
|
|
227
|
+
: __I extends { $props: infer __P }
|
|
228
|
+
? __P
|
|
229
|
+
: {}
|
|
230
|
+
: C extends (props: infer __P, ...args: any[]) => any
|
|
231
|
+
? __P
|
|
232
|
+
: {};
|
|
233
|
+
type $InstanceRawProps<C> = C extends { new (): { readonly __vizeRawProps?: infer __P } }
|
|
234
|
+
? $IsAny<__P> extends true
|
|
235
|
+
? $PublicProps<C>
|
|
236
|
+
: __P
|
|
237
|
+
: $PublicProps<C>;
|
|
238
|
+
type $StaticRawProps<C> = C extends { readonly __vizeRawProps?: infer __P }
|
|
239
|
+
? $IsAny<__P> extends true
|
|
240
|
+
? $PublicProps<C>
|
|
241
|
+
: __P
|
|
242
|
+
: $PublicProps<C>;
|
|
243
|
+
type $HasInstanceRawProps<C> =
|
|
244
|
+
$IsGeneratedComponent<C> extends true
|
|
245
|
+
? C extends { new (): { readonly __vizeRawProps?: infer __P } }
|
|
246
|
+
? $IsAny<__P> extends true
|
|
247
|
+
? false
|
|
248
|
+
: true
|
|
249
|
+
: false
|
|
250
|
+
: false;
|
|
251
|
+
type $HasStaticRawProps<C> =
|
|
252
|
+
$IsGeneratedComponent<C> extends true
|
|
253
|
+
? C extends { readonly __vizeRawProps?: infer __P }
|
|
254
|
+
? $IsAny<__P> extends true
|
|
255
|
+
? false
|
|
256
|
+
: true
|
|
257
|
+
: false
|
|
258
|
+
: false;
|
|
259
|
+
export type $ComponentRawProps<
|
|
260
|
+
C,
|
|
261
|
+
__P = $HasInstanceRawProps<C> extends true
|
|
262
|
+
? $InstanceRawProps<C>
|
|
263
|
+
: $HasStaticRawProps<C> extends true
|
|
264
|
+
? $StaticRawProps<C>
|
|
265
|
+
: $PublicProps<C>,
|
|
266
|
+
> = unknown extends __P ? Record<string, unknown> : __P;
|
|
494
267
|
type $HasRawProps<C> = $HasInstanceRawProps<C> extends true ? true : $HasStaticRawProps<C>;
|
|
495
|
-
export type $FallthroughValue<C, K extends PropertyKey> =
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
type $
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
268
|
+
export type $FallthroughValue<C, K extends PropertyKey> =
|
|
269
|
+
$HasFallthroughProps<C> extends true
|
|
270
|
+
? C extends { readonly __vizeFallthroughProps?: infer __F }
|
|
271
|
+
? $IsAny<__F> extends true
|
|
272
|
+
? unknown
|
|
273
|
+
: $PropValue<NonNullable<__F>, K, unknown>
|
|
274
|
+
: unknown
|
|
275
|
+
: unknown;
|
|
276
|
+
type $EventName<K extends string> = K extends `on${infer E}`
|
|
277
|
+
? Uncapitalize<E> | $KebabCase<Uncapitalize<E>>
|
|
278
|
+
: never;
|
|
279
|
+
type $KebabEventAliases<E> = {
|
|
280
|
+
[K in keyof E & string as $KebabCase<K> extends K ? never : $KebabCase<K>]: E[K];
|
|
281
|
+
};
|
|
282
|
+
export type $ComponentEvents<C> = C extends {
|
|
283
|
+
__vizeRawEmits?: infer __R;
|
|
284
|
+
__vizeEventMap?: infer __E;
|
|
285
|
+
}
|
|
286
|
+
? [keyof NonNullable<__R>] extends [never]
|
|
287
|
+
? NonNullable<__E>
|
|
288
|
+
: NonNullable<__R> & $KebabEventAliases<NonNullable<__R>>
|
|
289
|
+
: {
|
|
290
|
+
[
|
|
291
|
+
K in keyof (C extends { new (...args: any[]): { $props: infer __P } }
|
|
292
|
+
? __P
|
|
293
|
+
: C extends (props: infer __P, ...args: any[]) => any
|
|
294
|
+
? __P
|
|
295
|
+
: {}) &
|
|
296
|
+
string as $EventName<K>
|
|
297
|
+
]: (C extends { new (...args: any[]): { $props: infer __P } }
|
|
298
|
+
? __P
|
|
299
|
+
: C extends (props: infer __P, ...args: any[]) => any
|
|
300
|
+
? __P
|
|
301
|
+
: {})[K];
|
|
302
|
+
};
|
|
303
|
+
export type $IsLibraryGenericExport<C> = C extends
|
|
304
|
+
| { __vizeCheck: any }
|
|
305
|
+
| { readonly __vizeComponentMarker: true }
|
|
306
|
+
? false
|
|
307
|
+
: C extends (...args: any[]) => infer __R
|
|
308
|
+
? 0 extends 1 & __R
|
|
309
|
+
? false
|
|
310
|
+
: "__ctx" extends keyof __R
|
|
311
|
+
? true
|
|
312
|
+
: false
|
|
313
|
+
: false;
|
|
314
|
+
export type $PropChecker<C, P, T> =
|
|
315
|
+
$IsAny<C> extends true
|
|
316
|
+
? (props: { readonly [K in keyof P]: P[K] } & Record<string, unknown>) => void
|
|
317
|
+
: C extends { __vizeCheck: infer __F }
|
|
318
|
+
? $IsAny<__F> extends true
|
|
319
|
+
? (props: $ComponentCheckProps<P, T>) => void
|
|
320
|
+
: unknown extends __F
|
|
321
|
+
? (props: $ComponentCheckProps<P, T>) => void
|
|
322
|
+
: __F extends (...args: any[]) => any
|
|
323
|
+
? __F
|
|
324
|
+
: (props: $ComponentCheckProps<P, T>) => void
|
|
325
|
+
: $IsLibraryGenericExport<C> extends true
|
|
326
|
+
? C
|
|
327
|
+
: (props: $ComponentCheckProps<P, T>) => void;
|
|
328
|
+
export type $PropValue<
|
|
329
|
+
P,
|
|
330
|
+
K extends PropertyKey,
|
|
331
|
+
F = unknown,
|
|
332
|
+
__V = P extends unknown ? (K extends keyof P ? P[K] : never) : never,
|
|
333
|
+
> = [__V] extends [never] ? F : __V;
|
|
334
|
+
type $InvalidFallthroughSpreadKeys<P, F, A> = {
|
|
335
|
+
[K in keyof A]-?: K extends keyof P | keyof $KebabProps<P>
|
|
336
|
+
? never
|
|
337
|
+
: K extends keyof F
|
|
338
|
+
? $IsAny<A[K]> extends true
|
|
339
|
+
? never
|
|
340
|
+
: A[K] extends F[K]
|
|
341
|
+
? never
|
|
342
|
+
: K extends "id"
|
|
343
|
+
? A[K] extends string | number
|
|
344
|
+
? never
|
|
345
|
+
: K
|
|
346
|
+
: K
|
|
347
|
+
: never;
|
|
348
|
+
}[keyof A];
|
|
349
|
+
type $FallthroughSpreadGuard<
|
|
350
|
+
C,
|
|
351
|
+
P,
|
|
352
|
+
A,
|
|
353
|
+
__K = $InvalidFallthroughSpreadKeys<P, $FallthroughProps<C>, A>,
|
|
354
|
+
> = [__K] extends [never] ? unknown : { readonly __vizeInvalidFallthroughSpreadValues: __K };
|
|
355
|
+
export type $FallthroughSpreadChecker<C, P> = <A>(
|
|
356
|
+
props: A & $FallthroughSpreadGuard<C, P, NoInfer<A>>,
|
|
357
|
+
) => A;
|
|
358
|
+
export type $CallableProp<T> =
|
|
359
|
+
$IsAny<T> extends true ? T : unknown extends T ? (...args: any[]) => any : T;
|
|
360
|
+
export type $PropsResolver<C> = C extends { __vizeResolveProps?: infer __F }
|
|
361
|
+
? __F extends (...args: any[]) => any
|
|
362
|
+
? __F
|
|
363
|
+
: (props: any) => {}
|
|
364
|
+
: $IsLibraryGenericExport<C> extends true
|
|
365
|
+
? C
|
|
366
|
+
: (props: any) => {};
|
|
367
|
+
export type $ResolvedContextProps = <R>(
|
|
368
|
+
resolved: R,
|
|
369
|
+
) => R extends { __ctx?: infer __X }
|
|
370
|
+
? NonNullable<__X> extends { props: infer __P }
|
|
371
|
+
? __P
|
|
372
|
+
: R
|
|
373
|
+
: R;
|
|
508
374
|
export type $PropsSelector<R> = <A extends Partial<R> & Record<string, unknown>>(props: A) => A;
|
|
509
375
|
type $MissingProp = { readonly __vizeMissingProp: unique symbol };
|
|
510
|
-
type $ResolvedPropEntry<R, K extends PropertyKey> = R extends unknown
|
|
511
|
-
|
|
512
|
-
|
|
376
|
+
type $ResolvedPropEntry<R, K extends PropertyKey> = R extends unknown
|
|
377
|
+
? K extends keyof R
|
|
378
|
+
? { value: R[K] }
|
|
379
|
+
: $MissingProp
|
|
380
|
+
: never;
|
|
381
|
+
type $SelectedProps<R, A> = R extends unknown ? (A extends Partial<R> ? R : never) : never;
|
|
382
|
+
export type $ResolvedProp<
|
|
383
|
+
R,
|
|
384
|
+
A,
|
|
385
|
+
K extends PropertyKey,
|
|
386
|
+
F,
|
|
387
|
+
__S = $SelectedProps<R, A>,
|
|
388
|
+
__E = $ResolvedPropEntry<__S, K>,
|
|
389
|
+
__A = $ResolvedPropEntry<R, K>,
|
|
390
|
+
__P = Extract<__E, { value: unknown }>,
|
|
391
|
+
> = [__S] extends [never]
|
|
392
|
+
? F
|
|
393
|
+
: [__P] extends [never]
|
|
394
|
+
? [Extract<__A, { value: unknown }>] extends [never]
|
|
395
|
+
? F
|
|
396
|
+
: never
|
|
397
|
+
: __P extends { value: infer V }
|
|
398
|
+
? V
|
|
399
|
+
: never;
|
|
513
400
|
export type $ComponentRefCallback = (ref: any, refs: Record<string, any>) => void;
|
|
514
|
-
export type $StructuralSlots<C> = C extends { readonly __vizeSlots?: infer __S }
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
401
|
+
export type $StructuralSlots<C> = C extends { readonly __vizeSlots?: infer __S }
|
|
402
|
+
? NonNullable<__S>
|
|
403
|
+
: any;
|
|
404
|
+
type $EmptyVueNavigationSlots<C> =
|
|
405
|
+
| "__isFragment"
|
|
406
|
+
| "__isTeleport"
|
|
407
|
+
| "__isSuspense"
|
|
408
|
+
| "slots" extends keyof C
|
|
409
|
+
? $IsAny<C[Extract<"__isFragment" | "__isTeleport" | "__isSuspense", keyof C>]> extends true
|
|
410
|
+
? any
|
|
411
|
+
: [NonNullable<C[Extract<"__isFragment" | "__isTeleport" | "__isSuspense", keyof C>]>] extends [
|
|
412
|
+
never,
|
|
413
|
+
]
|
|
414
|
+
? C extends { slots?: infer __S }
|
|
415
|
+
? $IsAny<__S> extends true
|
|
416
|
+
? any
|
|
417
|
+
: unknown extends __S
|
|
418
|
+
? any
|
|
419
|
+
: [keyof NonNullable<__S>] extends [never]
|
|
420
|
+
? C extends { setup?: (props: infer __P, ...args: any[]) => any }
|
|
421
|
+
? string extends keyof __P
|
|
422
|
+
? any
|
|
423
|
+
: {}
|
|
424
|
+
: {}
|
|
425
|
+
: any
|
|
426
|
+
: any
|
|
427
|
+
: any
|
|
428
|
+
: any;
|
|
429
|
+
type $NativeNavigationSlots<C> = C extends new (...args: any[]) => { $slots: any }
|
|
430
|
+
? $IsAny<InstanceType<C>> extends true
|
|
431
|
+
? $EmptyVueNavigationSlots<C>
|
|
432
|
+
: $IsAny<InstanceType<C>["$slots"]> extends true
|
|
433
|
+
? any
|
|
434
|
+
: unknown extends InstanceType<C>["$slots"]
|
|
435
|
+
? any
|
|
436
|
+
: InstanceType<C>["$slots"]
|
|
437
|
+
: any;
|
|
438
|
+
export type $NavigationSlots<C> =
|
|
439
|
+
$IsAny<C> extends true
|
|
440
|
+
? any
|
|
441
|
+
: C extends { readonly __vizeSlots?: infer __S }
|
|
442
|
+
? $IsAny<__S> extends true
|
|
443
|
+
? __S
|
|
444
|
+
: unknown extends __S
|
|
445
|
+
? [keyof NonNullable<__S>] extends [never]
|
|
446
|
+
? $NativeNavigationSlots<C>
|
|
447
|
+
: NonNullable<__S>
|
|
448
|
+
: NonNullable<__S>
|
|
449
|
+
: $NativeNavigationSlots<C>;
|
|
450
|
+
type $RequiredSlotKeys<__S> = {
|
|
451
|
+
[__K in keyof __S]-?: undefined extends __S[__K] ? never : __K;
|
|
452
|
+
}[keyof __S];
|
|
519
453
|
type $MissingRequiredSlots<__S, __P> = Exclude<$RequiredSlotKeys<__S>, keyof __P>;
|
|
520
|
-
export type $RequiredSlots<__S, __P> =
|
|
521
|
-
|
|
522
|
-
|
|
454
|
+
export type $RequiredSlots<__S, __P> =
|
|
455
|
+
$IsAny<__S> extends true
|
|
456
|
+
? {}
|
|
457
|
+
: string extends keyof __S
|
|
458
|
+
? {}
|
|
459
|
+
: [keyof __S] extends [never]
|
|
460
|
+
? {}
|
|
461
|
+
: [$MissingRequiredSlots<__S, __P>] extends [never]
|
|
462
|
+
? {}
|
|
463
|
+
: { readonly __vizeMissingSlots: $MissingRequiredSlots<__S, __P> };
|
|
464
|
+
export type $SlotChildren<__S, __K extends PropertyKey> =
|
|
465
|
+
$IsAny<__S> extends true
|
|
466
|
+
? any
|
|
467
|
+
: string extends keyof __S
|
|
468
|
+
? any
|
|
469
|
+
: __K extends keyof __S
|
|
470
|
+
? ReturnType<Extract<NonNullable<__S[__K]>, (...args: any[]) => any>>
|
|
471
|
+
: any;
|
|
472
|
+
export type $ProvidedSlotChildren<__T extends unknown[]> = __T extends [infer __Only]
|
|
473
|
+
? __Only | __T
|
|
474
|
+
: __T;
|