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
|
@@ -87,9 +87,7 @@ type $IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
|
|
|
87
87
|
type $NotUndefined<T> = T extends undefined ? never : T;
|
|
88
88
|
type $MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
|
|
89
89
|
type $DefaultNativeType = null | number | string | boolean | symbol | Function;
|
|
90
|
-
type $InferDefault<P, T> =
|
|
91
|
-
| ((props: P) => T & {})
|
|
92
|
-
| (T extends $DefaultNativeType ? T : never);
|
|
90
|
+
type $InferDefault<P, T> = ((props: P) => T & {}) | (T extends $DefaultNativeType ? T : never);
|
|
93
91
|
type __WithDefaultsArgs<T> = { [K in keyof T]?: $InferDefault<T, T[K]> };
|
|
94
92
|
type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unknown
|
|
95
93
|
? Readonly<$MappedOmit<T, keyof D>> & {
|
|
@@ -109,10 +107,7 @@ type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unk
|
|
|
109
107
|
type __Ref<T> = import("vue").Ref<T>;
|
|
110
108
|
type __ShallowRef<T> = import("vue").ShallowRef<T>;
|
|
111
109
|
|
|
112
|
-
type $KebabCase<
|
|
113
|
-
S extends string,
|
|
114
|
-
Acc extends string = "",
|
|
115
|
-
> = S extends `${infer Head}${infer Tail}`
|
|
110
|
+
type $KebabCase<S extends string, Acc extends string = ""> = S extends `${infer Head}${infer Tail}`
|
|
116
111
|
? Head extends Lowercase<Head>
|
|
117
112
|
? $KebabCase<Tail, `${Acc}${Head}`>
|
|
118
113
|
: $KebabCase<Tail, `${Acc}-${Lowercase<Head>}`>
|
|
@@ -150,12 +145,8 @@ type $UnownedComponentAttrs<F, P = {}, E = {}> =
|
|
|
150
145
|
? F
|
|
151
146
|
: { [K in keyof F as K extends $ComponentOwnKeys<P, E> ? never : K]: F[K] }
|
|
152
147
|
: never;
|
|
153
|
-
type $Prettify<T> = (T extends any
|
|
154
|
-
|
|
155
|
-
: { [K in keyof T as K]: T[K] }) & {};
|
|
156
|
-
type $ComponentFallthroughSurface<C> = (C extends {
|
|
157
|
-
new (...args: any[]): { $props: infer __P };
|
|
158
|
-
}
|
|
148
|
+
type $Prettify<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
|
|
149
|
+
type $ComponentFallthroughSurface<C> = (C extends { new (...args: any[]): { $props: infer __P } }
|
|
159
150
|
? __P
|
|
160
151
|
: C extends (props: infer __P, ...args: any[]) => any
|
|
161
152
|
? __P
|
|
@@ -227,8 +218,7 @@ type $ComponentMissingInputGuard<T, Authored> = T extends unknown
|
|
|
227
218
|
}
|
|
228
219
|
: never;
|
|
229
220
|
type $ComponentInputGuardFor<T, Declared, Authored, Allowed> = [
|
|
230
|
-
| $
|
|
231
|
-
| $ExtraInputKeys<T, Declared, Authored, Allowed>,
|
|
221
|
+
$MissingRequiredInputKeys<T, Authored> | $ExtraInputKeys<T, Declared, Authored, Allowed>,
|
|
232
222
|
] extends [never]
|
|
233
223
|
? {}
|
|
234
224
|
: {
|
|
@@ -273,11 +263,9 @@ type $LiteralKeys<T> = keyof {
|
|
|
273
263
|
};
|
|
274
264
|
type $ReplaceComponentProps<T, P> = Omit<T, "$props"> &
|
|
275
265
|
Pick<T, Exclude<$LiteralKeys<T>, "$props">> & { $props: P };
|
|
276
|
-
type $PublicEmit<
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
K extends keyof S & string = keyof S & string,
|
|
280
|
-
> = S extends (...args: any[]) => any
|
|
266
|
+
type $PublicEmit<T, S = __EmitShape<T>, K extends keyof S & string = keyof S & string> = S extends (
|
|
267
|
+
...args: any[]
|
|
268
|
+
) => any
|
|
281
269
|
? S
|
|
282
270
|
: [K] extends [never]
|
|
283
271
|
? (event: string, ...args: any[]) => void
|
|
@@ -285,8 +273,8 @@ type $PublicEmit<
|
|
|
285
273
|
type $PublicSlots<T> = [keyof T] extends [never]
|
|
286
274
|
? import("vue").ComponentPublicInstance["$slots"]
|
|
287
275
|
: T;
|
|
288
|
-
// @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
|
|
289
276
|
type $ComponentPublicBase = Omit<
|
|
277
|
+
// @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
|
|
290
278
|
import("vue").ComponentPublicInstance,
|
|
291
279
|
"$props" | "$emit" | "$slots"
|
|
292
280
|
>;
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "vize",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.609.0",
|
|
4
4
|
"description": "Vize - High-performance Vue.js toolchain in Rust",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"cli",
|
|
@@ -31,6 +31,8 @@
|
|
|
31
31
|
"content-mapper-helpers.d.mts",
|
|
32
32
|
"content-mapper-helpers.d.ts",
|
|
33
33
|
"generated/content-mapper-types.d.ts",
|
|
34
|
+
"virtual-ts-globals.d.ts",
|
|
35
|
+
"virtual-ts-patterns.d.ts",
|
|
34
36
|
"virtual-ts.d.ts",
|
|
35
37
|
"virtual-ts.d.mts",
|
|
36
38
|
"virtual-ts.d.cts",
|
|
@@ -78,7 +80,7 @@
|
|
|
78
80
|
"access": "public"
|
|
79
81
|
},
|
|
80
82
|
"dependencies": {
|
|
81
|
-
"@vizejs/native": "0.
|
|
83
|
+
"@vizejs/native": "0.609.0",
|
|
82
84
|
"oxc-transform": "0.144.0"
|
|
83
85
|
},
|
|
84
86
|
"devDependencies": {
|
|
@@ -0,0 +1,489 @@
|
|
|
1
|
+
// Shared ambient helpers for vize virtual TypeScript.
|
|
2
|
+
declare global {
|
|
3
|
+
// ============================================
|
|
4
|
+
// Shared ambient helpers for vize virtual TypeScript
|
|
5
|
+
// Generated by vize
|
|
6
|
+
// ============================================
|
|
7
|
+
// Global script: one copy of these declarations per program replaces the
|
|
8
|
+
// preamble previously embedded in every generated .vue.ts module.
|
|
9
|
+
|
|
10
|
+
// ImportMeta augmentation (reference existing framework types)
|
|
11
|
+
// Extend ImportMeta with Nuxt-specific properties not covered by vite/client
|
|
12
|
+
interface ImportMeta {
|
|
13
|
+
client: boolean;
|
|
14
|
+
server: boolean;
|
|
15
|
+
dev: boolean;
|
|
16
|
+
prod: boolean;
|
|
17
|
+
ssr: boolean;
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
namespace JSX {
|
|
21
|
+
interface IntrinsicAttributes {
|
|
22
|
+
class?: unknown;
|
|
23
|
+
style?: unknown;
|
|
24
|
+
}
|
|
25
|
+
}
|
|
26
|
+
// vue-tsc generic library components accept unknown attrs through this
|
|
27
|
+
// fallback, which vue-tsc itself declares unless `checkUnknownProps` is set.
|
|
28
|
+
var __VLS_PROPS_FALLBACK: Record<string, unknown>;
|
|
29
|
+
|
|
30
|
+
// Shared type helpers used by generated virtual modules
|
|
31
|
+
type __EmitShape<T> = T extends (...args: any[]) => any
|
|
32
|
+
? T
|
|
33
|
+
: T extends Record<string, any>
|
|
34
|
+
? {
|
|
35
|
+
[K in keyof T]: T[K] extends (...args: infer A) => any
|
|
36
|
+
? A
|
|
37
|
+
: T[K] extends any[]
|
|
38
|
+
? T[K]
|
|
39
|
+
: any[];
|
|
40
|
+
}
|
|
41
|
+
: Record<string, any[]>;
|
|
42
|
+
type __EmitArgs<T, K extends keyof T> = T[K] extends any[] ? T[K] : any[];
|
|
43
|
+
type __EmitFn<
|
|
44
|
+
T,
|
|
45
|
+
__S = __EmitShape<T>,
|
|
46
|
+
__K extends keyof __S & string = keyof __S & string,
|
|
47
|
+
__U = { [K in __K]: (event: K, ...args: __EmitArgs<__S, K>) => void }[__K],
|
|
48
|
+
> = __S extends (...args: any[]) => any
|
|
49
|
+
? __S
|
|
50
|
+
: [__K] extends [never]
|
|
51
|
+
? (event: never, ...args: any[]) => void
|
|
52
|
+
: (__U extends unknown ? (fn: __U) => void : never) extends (fn: infer __I) => void
|
|
53
|
+
? __I
|
|
54
|
+
: never;
|
|
55
|
+
type __RuntimePropValue<T> = T extends abstract new (...args: any[]) => infer V
|
|
56
|
+
? V
|
|
57
|
+
: T extends (...args: any[]) => infer V
|
|
58
|
+
? V
|
|
59
|
+
: never;
|
|
60
|
+
type __RuntimePropCtorInner<T> = T extends null | undefined
|
|
61
|
+
? never
|
|
62
|
+
: T extends readonly (infer U)[]
|
|
63
|
+
? __RuntimePropCtorInner<U>
|
|
64
|
+
: T extends { type: infer U }
|
|
65
|
+
? __RuntimePropCtorInner<U>
|
|
66
|
+
: T extends StringConstructor
|
|
67
|
+
? string
|
|
68
|
+
: T extends NumberConstructor
|
|
69
|
+
? number
|
|
70
|
+
: T extends BooleanConstructor
|
|
71
|
+
? boolean
|
|
72
|
+
: T extends ArrayConstructor
|
|
73
|
+
? unknown[]
|
|
74
|
+
: T extends ObjectConstructor
|
|
75
|
+
? Record<string, any>
|
|
76
|
+
: T extends DateConstructor
|
|
77
|
+
? Date
|
|
78
|
+
: T extends FunctionConstructor
|
|
79
|
+
? (...args: any[]) => any
|
|
80
|
+
: __RuntimePropValue<T>;
|
|
81
|
+
type __RuntimePropCtor<T> = [__RuntimePropCtorInner<T>] extends [never]
|
|
82
|
+
? unknown
|
|
83
|
+
: __RuntimePropCtorInner<T>;
|
|
84
|
+
type __RuntimePropHasBoolean<T> = T extends BooleanConstructor
|
|
85
|
+
? true
|
|
86
|
+
: T extends readonly (infer U)[]
|
|
87
|
+
? __RuntimePropHasBoolean<U>
|
|
88
|
+
: T extends { type: infer U }
|
|
89
|
+
? __RuntimePropHasBoolean<U>
|
|
90
|
+
: false;
|
|
91
|
+
type __RuntimePropResolved<T> = T extends { required: true }
|
|
92
|
+
? true
|
|
93
|
+
: T extends { default: any }
|
|
94
|
+
? true
|
|
95
|
+
: __RuntimePropHasBoolean<T>;
|
|
96
|
+
type __RuntimePropShape<T extends Record<string, any>> = {
|
|
97
|
+
[K in keyof T]: __RuntimePropResolved<T[K]> extends true
|
|
98
|
+
? __RuntimePropCtor<T[K]>
|
|
99
|
+
: __RuntimePropCtor<T[K]> | undefined;
|
|
100
|
+
};
|
|
101
|
+
type $IsAny<T> = 0 extends 1 & T ? true : false;
|
|
102
|
+
type __LooseRequired<T> = { [P in keyof (T & Required<T>)]: T[P] };
|
|
103
|
+
type $BooleanKey<T, K extends keyof T = keyof T> = K extends any
|
|
104
|
+
? [Exclude<T[K], undefined>] extends [never]
|
|
105
|
+
? never
|
|
106
|
+
: [Exclude<T[K], undefined>] extends [boolean]
|
|
107
|
+
? K
|
|
108
|
+
: never
|
|
109
|
+
: never;
|
|
110
|
+
type __DefineProps<T, __BKeys extends keyof T = $BooleanKey<T>> = Readonly<T> & {
|
|
111
|
+
readonly [K in __BKeys]-?: boolean;
|
|
112
|
+
};
|
|
113
|
+
type $IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
|
|
114
|
+
type $NotUndefined<T> = T extends undefined ? never : T;
|
|
115
|
+
type $MappedOmit<T, K extends keyof any> = { [P in keyof T as P extends K ? never : P]: T[P] };
|
|
116
|
+
type $DefaultNativeType = null | number | string | boolean | symbol | Function;
|
|
117
|
+
type $InferDefault<P, T> = ((props: P) => T & {}) | (T extends $DefaultNativeType ? T : never);
|
|
118
|
+
type __WithDefaultsArgs<T> = { [K in keyof T]?: $InferDefault<T, T[K]> };
|
|
119
|
+
type __WithDefaultsResult<T, D, __BKeys extends keyof T = never> = T extends unknown
|
|
120
|
+
? Readonly<$MappedOmit<T, keyof D>> & {
|
|
121
|
+
readonly [K in keyof D as K extends keyof T ? K : never]-?: K extends keyof T
|
|
122
|
+
? D[K] extends undefined
|
|
123
|
+
? $IfAny<D[K], $NotUndefined<T[K]>, T[K]>
|
|
124
|
+
: $NotUndefined<T[K]>
|
|
125
|
+
: never;
|
|
126
|
+
} & {
|
|
127
|
+
readonly [K in __BKeys]-?: K extends keyof D
|
|
128
|
+
? D[K] extends undefined
|
|
129
|
+
? boolean | undefined
|
|
130
|
+
: boolean
|
|
131
|
+
: boolean;
|
|
132
|
+
}
|
|
133
|
+
: never;
|
|
134
|
+
type __Ref<T> = import("vue").Ref<T>;
|
|
135
|
+
type __ShallowRef<T> = import("vue").ShallowRef<T>;
|
|
136
|
+
type $KebabCase<
|
|
137
|
+
S extends string,
|
|
138
|
+
Acc extends string = "",
|
|
139
|
+
> = S extends `${infer Head}${infer Tail}`
|
|
140
|
+
? Head extends Lowercase<Head>
|
|
141
|
+
? $KebabCase<Tail, `${Acc}${Head}`>
|
|
142
|
+
: $KebabCase<Tail, `${Acc}-${Lowercase<Head>}`>
|
|
143
|
+
: `${Acc}${S}`;
|
|
144
|
+
type $KebabProps<T> = { [K in keyof T & string as $KebabCase<K>]: T[K] };
|
|
145
|
+
type $RequiredKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T];
|
|
146
|
+
type $DomListenerProps = {
|
|
147
|
+
[K in keyof GlobalEventHandlersEventMap as K extends string ? `on${Capitalize<K>}` : never]?: (
|
|
148
|
+
event: GlobalEventHandlersEventMap[K],
|
|
149
|
+
) => void;
|
|
150
|
+
};
|
|
151
|
+
type $FallthroughAttrs<Owned = {}> = { class?: unknown; style?: unknown } & {
|
|
152
|
+
[K in `data-${string}` | `data${Capitalize<string>}`]?: unknown;
|
|
153
|
+
} & { [K in `aria-${string}` | `aria${Capitalize<string>}`]?: unknown } & Omit<
|
|
154
|
+
$DomListenerProps,
|
|
155
|
+
keyof Owned
|
|
156
|
+
>;
|
|
157
|
+
// Match Vue's public prop contract, including runtime-core module augmentations.
|
|
158
|
+
type $PublicComponentInputProps = import("vue").VNodeProps &
|
|
159
|
+
import("vue").AllowedComponentProps &
|
|
160
|
+
import("vue").ComponentCustomProps;
|
|
161
|
+
type $ComponentMetadataKeys<T> =
|
|
162
|
+
$IsAny<T> extends true ? never : T extends unknown ? keyof NonNullable<T> : never;
|
|
163
|
+
type $ComponentOwnKeys<P = {}, E = {}> =
|
|
164
|
+
| keyof $PublicComponentInputProps
|
|
165
|
+
| $ComponentMetadataKeys<P>
|
|
166
|
+
| $ComponentMetadataKeys<E>;
|
|
167
|
+
type $UnownedComponentAttrs<F, P = {}, E = {}> =
|
|
168
|
+
$IsAny<F> extends true
|
|
169
|
+
? F
|
|
170
|
+
: unknown extends F
|
|
171
|
+
? F
|
|
172
|
+
: F extends unknown
|
|
173
|
+
? F extends null | undefined
|
|
174
|
+
? F
|
|
175
|
+
: { [K in keyof F as K extends $ComponentOwnKeys<P, E> ? never : K]: F[K] }
|
|
176
|
+
: never;
|
|
177
|
+
type $Prettify<T> = (T extends any
|
|
178
|
+
? { [K in keyof T]: T[K] }
|
|
179
|
+
: { [K in keyof T as K]: T[K] }) & {};
|
|
180
|
+
type $ComponentFallthroughSurface<C> = (C extends { new (...args: any[]): { $props: infer __P } }
|
|
181
|
+
? __P
|
|
182
|
+
: C extends (props: infer __P, ...args: any[]) => any
|
|
183
|
+
? __P
|
|
184
|
+
: Record<string, unknown>) &
|
|
185
|
+
(C extends { readonly __vizeFallthroughProps?: infer __F }
|
|
186
|
+
? $IsAny<__F> extends true
|
|
187
|
+
? {}
|
|
188
|
+
: NonNullable<__F>
|
|
189
|
+
: {});
|
|
190
|
+
type $ComponentFallthroughProps<C> = {
|
|
191
|
+
[K in keyof $ComponentFallthroughSurface<C>]: $ComponentFallthroughSurface<C>[K];
|
|
192
|
+
};
|
|
193
|
+
type $ComponentInputProps<T, Declared = {}> = T extends unknown
|
|
194
|
+
? Partial<T> &
|
|
195
|
+
Partial<$KebabProps<T>> &
|
|
196
|
+
Declared &
|
|
197
|
+
$FallthroughAttrs<T & Declared> &
|
|
198
|
+
$PublicComponentInputProps
|
|
199
|
+
: never;
|
|
200
|
+
type $MissingRequiredInputKeys<
|
|
201
|
+
T,
|
|
202
|
+
Authored,
|
|
203
|
+
K extends $RequiredKeys<T> & string = $RequiredKeys<T> & string,
|
|
204
|
+
> = K extends unknown
|
|
205
|
+
? K extends keyof Authored
|
|
206
|
+
? never
|
|
207
|
+
: $KebabCase<K> extends keyof Authored
|
|
208
|
+
? never
|
|
209
|
+
: K
|
|
210
|
+
: never;
|
|
211
|
+
type $IsPropKeyUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : false;
|
|
212
|
+
type $IsSinglePropKey<T> = [T] extends [never]
|
|
213
|
+
? false
|
|
214
|
+
: $IsPropKeyUnion<T> extends true
|
|
215
|
+
? false
|
|
216
|
+
: true;
|
|
217
|
+
type $RelaxedDynamicUnionExtra<T, Declared, Authored, K extends keyof Authored> = [
|
|
218
|
+
keyof Declared,
|
|
219
|
+
] extends [never]
|
|
220
|
+
? $IsSinglePropKey<$RequiredKeys<T>> extends true
|
|
221
|
+
? K extends string
|
|
222
|
+
? K extends `on${string}`
|
|
223
|
+
? false
|
|
224
|
+
: Authored[K] extends true
|
|
225
|
+
? false
|
|
226
|
+
: true
|
|
227
|
+
: false
|
|
228
|
+
: false
|
|
229
|
+
: false;
|
|
230
|
+
type $ExtraInputKeys<
|
|
231
|
+
T,
|
|
232
|
+
Declared,
|
|
233
|
+
Authored,
|
|
234
|
+
Allowed,
|
|
235
|
+
K extends keyof Authored = Exclude<keyof Authored, keyof Allowed>,
|
|
236
|
+
> = K extends unknown
|
|
237
|
+
? $RelaxedDynamicUnionExtra<T, Declared, Authored, K> extends true
|
|
238
|
+
? never
|
|
239
|
+
: K
|
|
240
|
+
: never;
|
|
241
|
+
type $ComponentMissingInputGuard<T, Authored> = T extends unknown
|
|
242
|
+
? [$MissingRequiredInputKeys<T, Authored>] extends [never]
|
|
243
|
+
? {}
|
|
244
|
+
: {
|
|
245
|
+
readonly __vizeInvalidComponentProps: {
|
|
246
|
+
readonly missing: $MissingRequiredInputKeys<T, Authored>;
|
|
247
|
+
readonly extra: never;
|
|
248
|
+
};
|
|
249
|
+
}
|
|
250
|
+
: never;
|
|
251
|
+
type $ComponentInputGuardFor<T, Declared, Authored, Allowed> = [
|
|
252
|
+
$MissingRequiredInputKeys<T, Authored> | $ExtraInputKeys<T, Declared, Authored, Allowed>,
|
|
253
|
+
] extends [never]
|
|
254
|
+
? {}
|
|
255
|
+
: {
|
|
256
|
+
readonly __vizeInvalidComponentProps: {
|
|
257
|
+
readonly missing: $MissingRequiredInputKeys<T, Authored>;
|
|
258
|
+
readonly extra: $ExtraInputKeys<T, Declared, Authored, Allowed>;
|
|
259
|
+
};
|
|
260
|
+
};
|
|
261
|
+
type $ComponentInputGuard<T, Declared, Authored> =
|
|
262
|
+
$UsePublicInstance<Authored> extends true
|
|
263
|
+
? {}
|
|
264
|
+
: T extends unknown
|
|
265
|
+
? $ComponentInputGuardFor<T, Declared, Authored, $ComponentInputProps<T, Declared>>
|
|
266
|
+
: never;
|
|
267
|
+
type $ComponentInputFor<T, Declared, Authored, Allowed> = Allowed &
|
|
268
|
+
$ComponentInputGuardFor<T, Declared, Authored, Allowed>;
|
|
269
|
+
type $ComponentInput<T, Declared, Authored> =
|
|
270
|
+
$UsePublicInstance<Authored> extends true
|
|
271
|
+
? $ComponentInputProps<T, Declared>
|
|
272
|
+
: T extends unknown
|
|
273
|
+
? $ComponentInputFor<T, Declared, Authored, $ComponentInputProps<T, Declared>>
|
|
274
|
+
: never;
|
|
275
|
+
type $AuthoredKeyWitness<T> = { [K in keyof T]: unknown };
|
|
276
|
+
type $IsUnknown<T> = unknown extends T ? ([keyof T] extends [never] ? true : false) : false;
|
|
277
|
+
type $UsePublicInstance<T> = $IsAny<T> extends true ? true : $IsUnknown<T>;
|
|
278
|
+
type $LiteralKeys<T> = keyof {
|
|
279
|
+
[
|
|
280
|
+
K in keyof T as K extends string
|
|
281
|
+
? string extends K
|
|
282
|
+
? never
|
|
283
|
+
: K extends `$${infer R}`
|
|
284
|
+
? string extends R
|
|
285
|
+
? never
|
|
286
|
+
: K
|
|
287
|
+
: K
|
|
288
|
+
: number extends K
|
|
289
|
+
? never
|
|
290
|
+
: symbol extends K
|
|
291
|
+
? never
|
|
292
|
+
: K
|
|
293
|
+
]: unknown;
|
|
294
|
+
};
|
|
295
|
+
type $ReplaceComponentProps<T, P> = Omit<T, "$props"> &
|
|
296
|
+
Pick<T, Exclude<$LiteralKeys<T>, "$props">> & { $props: P };
|
|
297
|
+
type $PublicEmit<
|
|
298
|
+
T,
|
|
299
|
+
S = __EmitShape<T>,
|
|
300
|
+
K extends keyof S & string = keyof S & string,
|
|
301
|
+
> = S extends (...args: any[]) => any
|
|
302
|
+
? S
|
|
303
|
+
: [K] extends [never]
|
|
304
|
+
? (event: string, ...args: any[]) => void
|
|
305
|
+
: __EmitFn<T>;
|
|
306
|
+
type $PublicSlots<T> = [keyof T] extends [never]
|
|
307
|
+
? import("vue").ComponentPublicInstance["$slots"]
|
|
308
|
+
: T;
|
|
309
|
+
type $ComponentPublicBase = Omit<
|
|
310
|
+
// @ts-ignore TS2694/TS2307: a `vue` without `ComponentPublicInstance` must degrade component public extras to unchecked, never error.
|
|
311
|
+
import("vue").ComponentPublicInstance,
|
|
312
|
+
"$props" | "$emit" | "$slots"
|
|
313
|
+
>;
|
|
314
|
+
// @ts-ignore TS2694/TS2307: a `vue` without `NativeElements` must degrade native prop checks to unchecked, never error. See virtual_ts/expressions/native_props.rs.
|
|
315
|
+
type $NativeElements = import("vue").NativeElements;
|
|
316
|
+
type $NativeElement<Tag extends PropertyKey> = Tag extends keyof $NativeElements
|
|
317
|
+
? $NativeElements[Tag]
|
|
318
|
+
: unknown;
|
|
319
|
+
type $NativeElementProp<Element, Prop extends PropertyKey> = Prop extends keyof Element
|
|
320
|
+
? Element[Prop]
|
|
321
|
+
: unknown;
|
|
322
|
+
function __vizeNativeElementProp<__Tag extends PropertyKey, __Prop extends PropertyKey>(
|
|
323
|
+
value: $NativeElementProp<$NativeElement<__Tag>, __Prop>,
|
|
324
|
+
): void;
|
|
325
|
+
type $ComponentAttrCamel<S extends string> = S extends `${infer __H}-${infer __T}`
|
|
326
|
+
? `${__H}${Capitalize<$ComponentAttrCamel<__T>>}`
|
|
327
|
+
: S;
|
|
328
|
+
type $ComponentNativeElementNames = Extract<keyof $NativeElements, string>;
|
|
329
|
+
type $ComponentNativeAttrNames = {
|
|
330
|
+
[K in $ComponentNativeElementNames]: Extract<keyof $NativeElements[K], string>;
|
|
331
|
+
}[$ComponentNativeElementNames];
|
|
332
|
+
type $ComponentGlobalHtmlAttrs =
|
|
333
|
+
$IsAny<$NativeElements> extends true
|
|
334
|
+
? {}
|
|
335
|
+
: { [K in $ComponentNativeAttrNames as K | $ComponentAttrCamel<K>]?: unknown } & {
|
|
336
|
+
[K in `data-${string}` | `data${Capitalize<string>}`]?: unknown;
|
|
337
|
+
};
|
|
338
|
+
function __vizeComponentGlobalHtmlAttrs(value: $ComponentGlobalHtmlAttrs): void;
|
|
339
|
+
function __vForList<const T>(
|
|
340
|
+
source: T,
|
|
341
|
+
): T extends number
|
|
342
|
+
? [item: number, key: number][]
|
|
343
|
+
: T extends string
|
|
344
|
+
? [item: string, key: number][]
|
|
345
|
+
: T extends readonly any[]
|
|
346
|
+
? (T extends readonly (infer U)[] ? [item: U, key: number] : never)[]
|
|
347
|
+
: T extends Iterable<any>
|
|
348
|
+
? (T extends Iterable<infer U> ? [item: U, key: number] : never)[]
|
|
349
|
+
: [
|
|
350
|
+
item: T[keyof T],
|
|
351
|
+
key: keyof T extends string ? keyof T : `${keyof T & (string | number)}`,
|
|
352
|
+
index: number,
|
|
353
|
+
][];
|
|
354
|
+
type $DirectiveHook<
|
|
355
|
+
D,
|
|
356
|
+
H = Extract<
|
|
357
|
+
D[keyof D &
|
|
358
|
+
(
|
|
359
|
+
| "created"
|
|
360
|
+
| "beforeMount"
|
|
361
|
+
| "mounted"
|
|
362
|
+
| "beforeUpdate"
|
|
363
|
+
| "updated"
|
|
364
|
+
| "beforeUnmount"
|
|
365
|
+
| "unmounted"
|
|
366
|
+
)],
|
|
367
|
+
(...args: any[]) => any
|
|
368
|
+
>,
|
|
369
|
+
> = D extends (...args: any[]) => any
|
|
370
|
+
? D
|
|
371
|
+
: [H] extends [never]
|
|
372
|
+
? (
|
|
373
|
+
el: unknown,
|
|
374
|
+
binding: { value?: unknown; arg?: unknown; modifiers?: unknown },
|
|
375
|
+
...args: any[]
|
|
376
|
+
) => void
|
|
377
|
+
: H;
|
|
378
|
+
type $DirectiveCall<H> = H extends (...args: any[]) => any
|
|
379
|
+
? Parameters<H>["length"] extends 0 | 1
|
|
380
|
+
? (el: unknown, binding: { value?: unknown; arg?: unknown; modifiers?: unknown }) => void
|
|
381
|
+
: H
|
|
382
|
+
: never;
|
|
383
|
+
function __vizeDirective<D>(directive: D): $DirectiveCall<$DirectiveHook<D>>;
|
|
384
|
+
// @ts-ignore TS2694/TS2307: a `vue` without `GlobalDirectives` must degrade registered directives to unchecked, never error.
|
|
385
|
+
type $GlobalDirectives = import("vue").GlobalDirectives;
|
|
386
|
+
// @ts-ignore TS2694/TS2307: a `vue` without `Directive` must degrade registered directives to unchecked, never error.
|
|
387
|
+
type $OwnDirectives<D> = D extends (infer L) & Record<string, import("vue").Directive> ? L : D;
|
|
388
|
+
type $LocalDirectives<C> = C extends { directives?: infer D }
|
|
389
|
+
? {
|
|
390
|
+
[
|
|
391
|
+
K in keyof $OwnDirectives<NonNullable<D>> & string as string extends K
|
|
392
|
+
? never
|
|
393
|
+
: `v${Capitalize<K>}`
|
|
394
|
+
]: $OwnDirectives<NonNullable<D>>[K];
|
|
395
|
+
}
|
|
396
|
+
: {};
|
|
397
|
+
function __vizeRegisteredDirective<C, K extends string>(): K extends keyof $LocalDirectives<C>
|
|
398
|
+
? $LocalDirectives<C>[K]
|
|
399
|
+
: K extends keyof $GlobalDirectives
|
|
400
|
+
? $GlobalDirectives[K]
|
|
401
|
+
: unknown;
|
|
402
|
+
function __vizeVaporDirective<D>(
|
|
403
|
+
directive: D,
|
|
404
|
+
): D extends (...args: any[]) => any
|
|
405
|
+
? D
|
|
406
|
+
: (node: unknown, value?: () => unknown, argument?: unknown, modifiers?: unknown) => void;
|
|
407
|
+
const __vizeDirectiveBindingRest: { instance: null; oldValue: null; modifiers: any; dir: any };
|
|
408
|
+
function __vizeDirectiveTail<F extends (...args: any[]) => any>(
|
|
409
|
+
hook: F,
|
|
410
|
+
): 4 extends Parameters<F>["length"]
|
|
411
|
+
? [never, never]
|
|
412
|
+
: 3 extends Parameters<F>["length"]
|
|
413
|
+
? [never]
|
|
414
|
+
: [];
|
|
415
|
+
|
|
416
|
+
// Emit-overload helpers (consumed by the per-file __EmitProps alias)
|
|
417
|
+
|
|
418
|
+
type $OverloadProps<TOverload> = Pick<TOverload, keyof TOverload>;
|
|
419
|
+
type $OverloadUnionRecursive<
|
|
420
|
+
TOverload,
|
|
421
|
+
TPartialOverload = unknown,
|
|
422
|
+
TDepth extends unknown[] = [],
|
|
423
|
+
> = TDepth["length"] extends 32
|
|
424
|
+
? never
|
|
425
|
+
: TOverload extends (...args: infer TArgs) => infer TReturn
|
|
426
|
+
? TPartialOverload extends TOverload
|
|
427
|
+
? never
|
|
428
|
+
:
|
|
429
|
+
| $OverloadUnionRecursive<
|
|
430
|
+
TPartialOverload & TOverload,
|
|
431
|
+
TPartialOverload & ((...args: TArgs) => TReturn) & $OverloadProps<TOverload>,
|
|
432
|
+
[...TDepth, unknown]
|
|
433
|
+
>
|
|
434
|
+
| ((...args: TArgs) => TReturn)
|
|
435
|
+
: never;
|
|
436
|
+
type $OverloadUnion<TOverload extends (...args: any[]) => any> = Exclude<
|
|
437
|
+
$OverloadUnionRecursive<(() => never) & TOverload>,
|
|
438
|
+
TOverload extends () => never ? never : () => never
|
|
439
|
+
>;
|
|
440
|
+
type $OverloadParameters<T extends (...args: any[]) => any> = Parameters<$OverloadUnion<T>>;
|
|
441
|
+
type $IsStringLiteral<T> = T extends string ? (string extends T ? false : true) : false;
|
|
442
|
+
type $ParametersToFns<T extends any[]> = string extends T[0]
|
|
443
|
+
? { [K in string]: (...args: T extends [e: any, ...args: infer P] ? P : any[]) => any }
|
|
444
|
+
: {
|
|
445
|
+
[K in T[0]]: $IsStringLiteral<K> extends true
|
|
446
|
+
? (
|
|
447
|
+
...args: T extends [e: infer E, ...args: infer P] ? (K extends E ? P : never) : never
|
|
448
|
+
) => any
|
|
449
|
+
: never;
|
|
450
|
+
};
|
|
451
|
+
type __EmitOptions<T, S = __EmitShape<T>> = {
|
|
452
|
+
[K in keyof S as K extends string ? K : never]: (...args: __EmitArgs<S, K>) => any;
|
|
453
|
+
} & (__EmitShape<T> extends (...args: any[]) => any
|
|
454
|
+
? $ParametersToFns<$OverloadParameters<__EmitShape<T>>>
|
|
455
|
+
: {});
|
|
456
|
+
type $Camelize<S extends string> = S extends `${infer Head}-${infer Tail}`
|
|
457
|
+
? `${Head}${Capitalize<$Camelize<Tail>>}`
|
|
458
|
+
: S;
|
|
459
|
+
type $HandlerKey<K extends string> = `on${Capitalize<$Camelize<K>>}`;
|
|
460
|
+
|
|
461
|
+
// Compiler-macro signatures (aliased inside each module's __setup() scope)
|
|
462
|
+
function __vize_defineProps<_T = unknown>(): __DefineProps<
|
|
463
|
+
__LooseRequired<_T>,
|
|
464
|
+
Extract<$BooleanKey<_T>, keyof __LooseRequired<_T>>
|
|
465
|
+
>;
|
|
466
|
+
function __vize_defineProps<const _T extends readonly string[]>(
|
|
467
|
+
_props: _T,
|
|
468
|
+
): { [K in _T[number]]?: any };
|
|
469
|
+
function __vize_defineProps<const _T extends Record<string, any>>(
|
|
470
|
+
_props: _T,
|
|
471
|
+
): __RuntimePropShape<_T>;
|
|
472
|
+
function __vize_defineEmits<_T = unknown>(): __EmitFn<_T>;
|
|
473
|
+
function __vize_defineEmits<const _T extends readonly string[]>(
|
|
474
|
+
_events: _T,
|
|
475
|
+
): (event: _T[number], ...args: any[]) => void;
|
|
476
|
+
function __vize_defineEmits<const _T extends Record<string, any>>(_events: _T): __EmitFn<_T>;
|
|
477
|
+
function __vize_defineExpose<_T = unknown>(_exposed?: _T): void;
|
|
478
|
+
const __vize_defineModel: typeof import("vue") extends { defineModel: infer __Macro }
|
|
479
|
+
? __Macro
|
|
480
|
+
: never;
|
|
481
|
+
function __vize_defineSlots<_T = unknown>(): _T;
|
|
482
|
+
function __vize_withDefaults<_T, _BKeys extends keyof _T, _D extends __WithDefaultsArgs<_T>>(
|
|
483
|
+
_props: __DefineProps<_T, _BKeys>,
|
|
484
|
+
_defaults: _D,
|
|
485
|
+
): __WithDefaultsResult<_T, _D, _BKeys>;
|
|
486
|
+
function __vize_useTemplateRef<_T = any>(_key: string): __ShallowRef<_T | null>;
|
|
487
|
+
}
|
|
488
|
+
|
|
489
|
+
export {};
|