deja-vue 0.2.0 → 2.0.1
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/README.md +41 -13
- package/dist/index.d.ts +497 -97
- package/dist/index.js +680 -187
- package/package.json +22 -24
package/dist/index.d.ts
CHANGED
|
@@ -1,139 +1,350 @@
|
|
|
1
|
-
import
|
|
2
|
-
import {
|
|
1
|
+
import { Component, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, ModelRef, Reactive, Ref, ShallowRef, ShallowUnwrapRef, WatchOptions } from "vue";
|
|
2
|
+
import { NodeRef } from "vue-unwrap";
|
|
3
|
+
import { SplitText } from "gsap/SplitText";
|
|
3
4
|
|
|
4
|
-
//#region src/
|
|
5
|
-
declare
|
|
6
|
-
declare const parentAnimationInjectionKey: InjectionKey<Animation>;
|
|
7
|
-
//#endregion
|
|
8
|
-
//#region src/utils/EventBus.d.ts
|
|
9
|
-
declare class EventBus<E extends string> {
|
|
5
|
+
//#region src/core/EventBus.d.ts
|
|
6
|
+
declare class EventBus<E extends string, A extends unknown[] = []> {
|
|
10
7
|
private bus;
|
|
11
8
|
constructor(events?: E[]);
|
|
12
|
-
on(event: E | E[], callback:
|
|
13
|
-
once(event: E | E[], callback:
|
|
14
|
-
off(event: E | E[], callback:
|
|
15
|
-
dispatch(event: E, ...args:
|
|
9
|
+
on(event: E | E[], callback: (...args: A) => void): void;
|
|
10
|
+
once(event: E | E[], callback: (...args: A) => void): void;
|
|
11
|
+
off(event: E | E[], callback: (...args: A) => void): void;
|
|
12
|
+
dispatch(event: E, ...args: A): void;
|
|
16
13
|
dispose(): void;
|
|
17
14
|
}
|
|
18
15
|
//#endregion
|
|
19
|
-
//#region src/
|
|
20
|
-
declare class Animation extends EventBus<
|
|
16
|
+
//#region src/core/Animation.d.ts
|
|
17
|
+
declare class Animation extends EventBus<AnimationEvent, [animation: Animation]> {
|
|
18
|
+
private ctx?;
|
|
19
|
+
private scrollTrigger?;
|
|
21
20
|
timeline: gsap.core.Timeline;
|
|
22
21
|
constructor(options?: gsap.TimelineVars);
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
22
|
+
attachScrollTrigger(vars: ScrollTrigger.Vars | null | undefined): void;
|
|
23
|
+
compose(definition: AnimationComposeDefinition, withContext?: boolean): void;
|
|
24
|
+
add(child: AnimationChild, position?: gsap.Position, timeShift?: boolean): void;
|
|
25
|
+
remove(child: AnimationChild, force?: boolean): void;
|
|
26
|
+
getChildPosition(child: AnimationChild): number | undefined;
|
|
27
|
+
run(action?: TweenAction, ...args: any[]): void;
|
|
28
|
+
clear(revert?: boolean): void;
|
|
26
29
|
dispose(): void;
|
|
30
|
+
private handleScrollTriggerReset;
|
|
27
31
|
}
|
|
28
32
|
//#endregion
|
|
29
33
|
//#region src/types.d.ts
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
34
|
+
type NonEmptyArray<T> = [T, ...T[]];
|
|
35
|
+
type PlainObject<T> = [T] extends [readonly unknown[]] ? never : T;
|
|
36
|
+
type DejaVueNode = NodeRef | ShallowUnwrapRef<DejaVueComponent>;
|
|
37
|
+
interface DejaVueComponent {
|
|
38
|
+
$el: ShallowRef<Element | null>;
|
|
39
|
+
seamless?: MaybeRef<boolean | undefined>;
|
|
40
|
+
tweenTarget: ComputedRef<gsap.TweenTarget>;
|
|
33
41
|
}
|
|
34
|
-
interface
|
|
35
|
-
|
|
36
|
-
|
|
42
|
+
interface DejaVueAnimationInstance extends DejaVueComponent {
|
|
43
|
+
animation: Animation;
|
|
44
|
+
controlled: boolean;
|
|
45
|
+
direction: Ref<AnimationDirection>;
|
|
46
|
+
parent: DejaVueAnimationParent | null;
|
|
47
|
+
progress: ModelRef<ControllableAnimation['progress']>;
|
|
37
48
|
}
|
|
38
|
-
interface
|
|
39
|
-
|
|
40
|
-
|
|
49
|
+
interface DejaVueAnimationComponentProps {
|
|
50
|
+
seamless?: boolean;
|
|
51
|
+
tweenTarget?: 'children' | 'self' | gsap.TweenTarget;
|
|
41
52
|
}
|
|
42
|
-
type
|
|
43
|
-
type
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
53
|
+
type DejaVueAnimationExposed = ShallowUnwrapRef<DejaVueAnimationInstance>;
|
|
54
|
+
type DejaVueAnimationParent = DejaVueAnimationInstance | DejaVueAnimationExposed;
|
|
55
|
+
type DejaVueAnimationScopeProps = Pick<DejaVueAnimationExposed, 'animation' | 'direction' | 'parent' | 'progress'>;
|
|
56
|
+
type AnimationChild = Animation | gsap.Callback | string;
|
|
57
|
+
type AnimationComposeDefinition = {
|
|
58
|
+
scope?: Element;
|
|
59
|
+
target: gsap.TweenTarget;
|
|
60
|
+
} & ({
|
|
61
|
+
method: 'fromTo';
|
|
62
|
+
vars: [gsap.TweenVars, gsap.TweenVars];
|
|
63
|
+
} | {
|
|
49
64
|
method: 'from' | 'to';
|
|
50
65
|
vars: gsap.TweenVars;
|
|
51
66
|
} | {
|
|
52
|
-
method:
|
|
53
|
-
vars:
|
|
67
|
+
method: string;
|
|
68
|
+
vars: Record<string, unknown>;
|
|
69
|
+
});
|
|
70
|
+
type AnimationDirection = 1 | -1 | 0;
|
|
71
|
+
type AnimationEvent = 'complete' | 'interrupt' | 'repeat' | 'reverseComplete' | 'start' | 'update';
|
|
72
|
+
type AnimationEventEmitter = (e: AnimationEvent, animation: Animation, parent: DejaVueAnimationParent | null) => void;
|
|
73
|
+
interface AnimationNestableChild {
|
|
74
|
+
parent?: DejaVueAnimationParent | null;
|
|
75
|
+
position?: gsap.Position;
|
|
76
|
+
}
|
|
77
|
+
interface AnimationTriggerOptions extends WatchOptions {
|
|
78
|
+
actionArgs?: any[];
|
|
79
|
+
}
|
|
80
|
+
type ControllableAnimation = {
|
|
81
|
+
progress?: number;
|
|
82
|
+
} & ({
|
|
83
|
+
trigger?: unknown;
|
|
84
|
+
triggerAction?: TweenAction;
|
|
85
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
54
86
|
} | {
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
87
|
+
trigger?: never;
|
|
88
|
+
triggerAction?: never;
|
|
89
|
+
triggerOptions?: never;
|
|
90
|
+
});
|
|
91
|
+
type TweenAction = 'play' | 'pause' | 'reset' | 'restart' | 'resume' | 'reverse';
|
|
92
|
+
type TweenDefinition = ({
|
|
93
|
+
from: gsap.TweenVars;
|
|
94
|
+
to: gsap.TweenVars;
|
|
95
|
+
effect?: never;
|
|
96
|
+
effectOptions?: never;
|
|
97
|
+
} | {
|
|
98
|
+
from: gsap.TweenVars;
|
|
99
|
+
to?: never;
|
|
100
|
+
effect?: never;
|
|
101
|
+
effectOptions?: never;
|
|
102
|
+
} | {
|
|
103
|
+
from?: never;
|
|
104
|
+
to: gsap.TweenVars;
|
|
105
|
+
effect?: never;
|
|
106
|
+
effectOptions?: never;
|
|
107
|
+
} | {
|
|
108
|
+
from?: never;
|
|
109
|
+
to?: never;
|
|
110
|
+
effect?: string;
|
|
111
|
+
effectOptions?: gsap.TweenVars;
|
|
112
|
+
});
|
|
113
|
+
interface WrappableComponent {
|
|
114
|
+
is?: string | Component;
|
|
115
|
+
}
|
|
59
116
|
//#endregion
|
|
60
|
-
//#region src/
|
|
61
|
-
|
|
62
|
-
|
|
63
|
-
|
|
64
|
-
|
|
65
|
-
|
|
66
|
-
|
|
117
|
+
//#region src/components/Marker.types.d.ts
|
|
118
|
+
interface DejaVueMarkerInstance {
|
|
119
|
+
crossed: Ref<boolean>;
|
|
120
|
+
parent: DejaVueAnimationParent | null;
|
|
121
|
+
}
|
|
122
|
+
type DejaVueMarkerExposed = ShallowUnwrapRef<DejaVueMarkerInstance>;
|
|
123
|
+
type DejaVueMarkerScopeProps = Pick<DejaVueMarkerExposed, 'crossed' | 'parent'>;
|
|
124
|
+
//#endregion
|
|
125
|
+
//#region src/components/SplitText.types.d.ts
|
|
126
|
+
interface DejaVueSplitTextScopeProps {
|
|
127
|
+
chars: Element[];
|
|
128
|
+
words: Element[];
|
|
129
|
+
lines: Element[];
|
|
130
|
+
}
|
|
131
|
+
type DejaVueSplitTextInstance = DejaVueComponent & { [K in keyof DejaVueSplitTextScopeProps]: Ref<DejaVueSplitTextScopeProps[K]> };
|
|
132
|
+
type DejaVueSplitTextExposed = ShallowUnwrapRef<DejaVueSplitTextInstance>;
|
|
133
|
+
//#endregion
|
|
134
|
+
//#region src/constants.d.ts
|
|
135
|
+
declare const ANIMATION_EVENTS: AnimationEvent[];
|
|
136
|
+
declare const dejaVueParentInstance: InjectionKey<DejaVueAnimationInstance>;
|
|
137
|
+
//#endregion
|
|
138
|
+
//#region src/utils/index.d.ts
|
|
139
|
+
declare function cloneObject<T extends object>(target: T): T;
|
|
140
|
+
declare function isObject(value: unknown): value is Record<string, unknown>;
|
|
141
|
+
declare function patchArray(target: unknown[], changes: unknown[]): void;
|
|
142
|
+
declare function patchObject<T extends object>(target: T, changes: T): void;
|
|
143
|
+
declare function syncData(target: unknown, changes: unknown): boolean;
|
|
144
|
+
declare function toNonEmptyArray<T = unknown>(data: T[]): NonEmptyArray<T> | null;
|
|
145
|
+
//#endregion
|
|
146
|
+
//#region src/utils/gsap.d.ts
|
|
147
|
+
declare function applyTimelineTotalDuration(timeline: gsap.core.Timeline): void;
|
|
148
|
+
declare function getScrollTriggerToggleActionByEvent(event: 'enter' | 'enterBack' | 'leave' | 'leaveBack', instance?: ScrollTrigger): string | undefined;
|
|
149
|
+
declare function isEmptyTarget(target: gsap.TweenTarget): boolean;
|
|
150
|
+
declare function resolveTimelinePosition(timeline: gsap.core.Timeline, position?: gsap.Position): number | null;
|
|
151
|
+
declare function stripScrollTriggerVars(vars: gsap.AnimationVars, defaultTrigger?: gsap.DOMTarget): ScrollTrigger.Vars | null;
|
|
67
152
|
//#endregion
|
|
68
153
|
//#region src/composables/useAnimationControls.d.ts
|
|
69
|
-
|
|
154
|
+
interface AnimationControls {
|
|
155
|
+
progress: ModelRef<number | undefined>;
|
|
156
|
+
trigger: MaybeRefOrGetter<unknown>;
|
|
157
|
+
triggerAction: MaybeRefOrGetter<TweenAction | undefined>;
|
|
158
|
+
triggerOptions: MaybeRefOrGetter<AnimationTriggerOptions | undefined>;
|
|
159
|
+
}
|
|
70
160
|
declare function useAnimationControls(animation: Animation, controls: AnimationControls): {
|
|
71
|
-
controlled:
|
|
161
|
+
controlled: boolean;
|
|
162
|
+
direction: import("vue").Ref<AnimationDirection, AnimationDirection>;
|
|
72
163
|
};
|
|
73
164
|
//#endregion
|
|
74
165
|
//#region src/composables/useAnimationNesting.d.ts
|
|
75
|
-
|
|
76
|
-
parent
|
|
166
|
+
interface AnimationNestingOptions {
|
|
167
|
+
parent?: DejaVueAnimationParent | null;
|
|
168
|
+
position?: MaybeRefOrGetter<gsap.Position | undefined>;
|
|
169
|
+
}
|
|
170
|
+
type AnimationNestingTarget = ({
|
|
171
|
+
animation: Animation;
|
|
172
|
+
} | {
|
|
173
|
+
callback: gsap.Callback;
|
|
174
|
+
} | {
|
|
175
|
+
label: MaybeRefOrGetter<string | undefined>;
|
|
176
|
+
});
|
|
177
|
+
declare function useAnimationNesting(target?: AnimationNestingTarget | AnimationNestingTarget[], options?: AnimationNestingOptions): {
|
|
178
|
+
parent: DejaVueAnimationParent | null;
|
|
179
|
+
};
|
|
180
|
+
//#endregion
|
|
181
|
+
//#region src/composables/useAnimationScope.d.ts
|
|
182
|
+
interface AnimationScopeOptions {
|
|
183
|
+
resolveChildrenTweenTarget?: (children: DejaVueNode[]) => Element[];
|
|
184
|
+
tweenTarget?: MaybeRefOrGetter<gsap.TweenTarget | undefined>;
|
|
185
|
+
}
|
|
186
|
+
declare function resolveChildrenTweenTarget(children: DejaVueNode[]): Element[];
|
|
187
|
+
declare function useAnimationScope(options?: AnimationScopeOptions): {
|
|
188
|
+
AnimationScope: {
|
|
189
|
+
(props: DejaVueAnimationScopeProps, context: import("vue").SetupContext): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
190
|
+
[key: string]: any;
|
|
191
|
+
}> | import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
|
|
192
|
+
[key: string]: any;
|
|
193
|
+
}>[];
|
|
194
|
+
inheritAttrs: boolean;
|
|
195
|
+
props: {
|
|
196
|
+
[x: string]: any;
|
|
197
|
+
};
|
|
198
|
+
};
|
|
199
|
+
root: import("vue").ShallowRef<Element | null, Element | null>;
|
|
200
|
+
tweenTarget: import("vue").ComputedRef<object | null>;
|
|
201
|
+
};
|
|
202
|
+
//#endregion
|
|
203
|
+
//#region src/composables/useSplitText.d.ts
|
|
204
|
+
interface SplitTextOptions {
|
|
205
|
+
type?: string;
|
|
206
|
+
mask?: 'lines' | 'words' | 'chars';
|
|
207
|
+
wordDelimiter?: string | RegExp | SplitText.WordDelimiterConfig;
|
|
208
|
+
linesClass?: string;
|
|
209
|
+
wordsClass?: string;
|
|
210
|
+
charsClass?: string;
|
|
211
|
+
aria?: 'auto' | 'hidden' | 'none';
|
|
212
|
+
tag?: string;
|
|
213
|
+
propIndex?: boolean;
|
|
214
|
+
deepSlice?: boolean;
|
|
215
|
+
smartWrap?: boolean;
|
|
216
|
+
specialChars?: string[] | RegExp;
|
|
217
|
+
reduceWhiteSpace?: boolean;
|
|
218
|
+
autoSplit?: boolean;
|
|
219
|
+
ignore?: SplitText.SplitTextTarget;
|
|
220
|
+
prepareText?: SplitText.PrepareTextFunction;
|
|
221
|
+
onSplit?: (splitText: SplitText) => void;
|
|
222
|
+
onRevert?: (splitText: SplitText) => void;
|
|
223
|
+
overwrite?: boolean;
|
|
224
|
+
}
|
|
225
|
+
declare function useSplitText(domTarget: MaybeRefOrGetter<gsap.DOMTarget>, options: MaybeRefOrGetter<SplitTextOptions>): {
|
|
226
|
+
chars: import("vue").Ref<Element[], Element[]>;
|
|
227
|
+
lines: import("vue").Ref<Element[], Element[]>;
|
|
228
|
+
words: import("vue").Ref<Element[], Element[]>;
|
|
229
|
+
instance: import("vue").ShallowRef<SplitText | undefined, SplitText | undefined>;
|
|
230
|
+
state: import("vue").ShallowReactive<{
|
|
231
|
+
chars: Element[];
|
|
232
|
+
lines: Element[];
|
|
233
|
+
words: Element[];
|
|
234
|
+
}>;
|
|
77
235
|
};
|
|
78
236
|
//#endregion
|
|
79
|
-
//#region src/
|
|
80
|
-
|
|
81
|
-
|
|
237
|
+
//#region src/composables/useStableObjectProp.d.ts
|
|
238
|
+
declare function useStableObjectProp<T extends object>(objectProp: MaybeRefOrGetter<PlainObject<T> | null | undefined>, watchOptions?: WatchOptions): Reactive<T>;
|
|
239
|
+
//#endregion
|
|
240
|
+
//#region src/composables/useTweenVars.d.ts
|
|
241
|
+
declare function useTweenVars(definition: TweenDefinition): {
|
|
242
|
+
method: import("vue").ComputedRef<string>;
|
|
243
|
+
vars: import("vue").ComputedRef<gsap.TweenVars | [gsap.TweenVars, gsap.TweenVars]>;
|
|
244
|
+
};
|
|
245
|
+
//#endregion
|
|
246
|
+
//#region src/components/Marker.vue.d.ts
|
|
247
|
+
type __VLS_Props$1 = AnimationNestableChild & {
|
|
248
|
+
label?: string;
|
|
82
249
|
};
|
|
83
|
-
|
|
250
|
+
type __VLS_Slots$3 = {
|
|
251
|
+
default(props: DejaVueMarkerScopeProps): any;
|
|
252
|
+
};
|
|
253
|
+
declare const __VLS_base$3: import("vue").DefineComponent<__VLS_Props$1, DejaVueMarkerInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
|
|
254
|
+
cross: (direction: AnimationDirection) => any;
|
|
255
|
+
}, string, import("vue").PublicProps, Readonly<__VLS_Props$1> & Readonly<{
|
|
256
|
+
onCross?: ((direction: AnimationDirection) => any) | undefined;
|
|
257
|
+
}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
|
|
258
|
+
declare const __VLS_export$3: __VLS_WithSlots$3<typeof __VLS_base$3, __VLS_Slots$3>;
|
|
84
259
|
declare const _default: typeof __VLS_export$3;
|
|
260
|
+
type __VLS_WithSlots$3<T, S> = T & {
|
|
261
|
+
new (): {
|
|
262
|
+
$slots: S;
|
|
263
|
+
};
|
|
264
|
+
};
|
|
85
265
|
//#endregion
|
|
86
|
-
//#region src/components/
|
|
87
|
-
type __VLS_Props =
|
|
88
|
-
|
|
266
|
+
//#region src/components/SplitText.vue.d.ts
|
|
267
|
+
type __VLS_Props = SplitTextOptions & {
|
|
268
|
+
tweenTarget?: 'lines' | 'words' | 'chars';
|
|
269
|
+
};
|
|
270
|
+
type __VLS_Slots$2 = {
|
|
271
|
+
default(props: DejaVueSplitTextScopeProps): any;
|
|
89
272
|
};
|
|
90
|
-
declare const
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
273
|
+
declare const __VLS_base$2: import("vue").DefineComponent<__VLS_Props, DejaVueSplitTextInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
|
|
274
|
+
revert: (splitText: SplitText) => any;
|
|
275
|
+
split: (splitText: SplitText) => any;
|
|
276
|
+
}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
|
|
277
|
+
onRevert?: ((splitText: SplitText) => any) | undefined;
|
|
278
|
+
onSplit?: ((splitText: SplitText) => any) | undefined;
|
|
279
|
+
}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
|
|
280
|
+
declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
|
|
95
281
|
declare const _default$1: typeof __VLS_export$2;
|
|
282
|
+
type __VLS_WithSlots$2<T, S> = T & {
|
|
283
|
+
new (): {
|
|
284
|
+
$slots: S;
|
|
285
|
+
};
|
|
286
|
+
};
|
|
96
287
|
//#endregion
|
|
97
288
|
//#region src/components/Timeline.vue.d.ts
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
controlled: boolean;
|
|
101
|
-
parent: Animation | null;
|
|
102
|
-
ready: boolean;
|
|
103
|
-
}, __VLS_11: {
|
|
104
|
-
animation: Animation;
|
|
105
|
-
controlled: boolean;
|
|
106
|
-
parent: Animation | null;
|
|
107
|
-
ready: boolean;
|
|
108
|
-
};
|
|
109
|
-
type __VLS_Slots$1 = {} & {
|
|
110
|
-
default?: (props: typeof __VLS_9$1) => any;
|
|
111
|
-
} & {
|
|
112
|
-
default?: (props: typeof __VLS_11) => any;
|
|
289
|
+
type __VLS_Slots$1 = {
|
|
290
|
+
default(props: DejaVueAnimationScopeProps): any;
|
|
113
291
|
};
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
}
|
|
292
|
+
type __VLS_ModelProps$1 = {
|
|
293
|
+
'progress'?: number;
|
|
294
|
+
};
|
|
295
|
+
declare const __VLS_base$1: import("vue").DefineComponent<(DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
296
|
+
progress?: number;
|
|
297
|
+
} & {
|
|
298
|
+
trigger?: unknown;
|
|
299
|
+
triggerAction?: TweenAction;
|
|
300
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
301
|
+
} & {
|
|
302
|
+
duration?: number;
|
|
303
|
+
options?: gsap.TimelineVars;
|
|
304
|
+
} & __VLS_ModelProps$1) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
305
|
+
progress?: number;
|
|
306
|
+
} & {
|
|
307
|
+
trigger?: never;
|
|
308
|
+
triggerAction?: never;
|
|
309
|
+
triggerOptions?: never;
|
|
310
|
+
} & {
|
|
311
|
+
duration?: number;
|
|
312
|
+
options?: gsap.TimelineVars;
|
|
313
|
+
} & __VLS_ModelProps$1), DejaVueAnimationInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
|
|
120
314
|
complete: (...args: any[]) => void;
|
|
121
315
|
interrupt: (...args: any[]) => void;
|
|
122
316
|
repeat: (...args: any[]) => void;
|
|
123
317
|
reverseComplete: (...args: any[]) => void;
|
|
124
318
|
start: (...args: any[]) => void;
|
|
125
319
|
update: (...args: any[]) => void;
|
|
126
|
-
|
|
320
|
+
"update:progress": (value: number) => void;
|
|
321
|
+
}, string, import("vue").PublicProps, Readonly<(DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
322
|
+
progress?: number;
|
|
323
|
+
} & {
|
|
324
|
+
trigger?: unknown;
|
|
325
|
+
triggerAction?: TweenAction;
|
|
326
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
327
|
+
} & {
|
|
328
|
+
duration?: number;
|
|
329
|
+
options?: gsap.TimelineVars;
|
|
330
|
+
} & __VLS_ModelProps$1) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
331
|
+
progress?: number;
|
|
332
|
+
} & {
|
|
333
|
+
trigger?: never;
|
|
334
|
+
triggerAction?: never;
|
|
335
|
+
triggerOptions?: never;
|
|
336
|
+
} & {
|
|
337
|
+
duration?: number;
|
|
338
|
+
options?: gsap.TimelineVars;
|
|
339
|
+
} & __VLS_ModelProps$1)> & Readonly<{
|
|
340
|
+
"onUpdate:progress"?: ((value: number) => any) | undefined;
|
|
127
341
|
onComplete?: ((...args: any[]) => any) | undefined;
|
|
128
342
|
onInterrupt?: ((...args: any[]) => any) | undefined;
|
|
129
343
|
onRepeat?: ((...args: any[]) => any) | undefined;
|
|
130
344
|
onReverseComplete?: ((...args: any[]) => any) | undefined;
|
|
131
345
|
onStart?: ((...args: any[]) => any) | undefined;
|
|
132
346
|
onUpdate?: ((...args: any[]) => any) | undefined;
|
|
133
|
-
}>, {
|
|
134
|
-
toggle: boolean;
|
|
135
|
-
tag: string;
|
|
136
|
-
}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
|
|
347
|
+
}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
|
|
137
348
|
declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
|
|
138
349
|
declare const _default$2: typeof __VLS_export$1;
|
|
139
350
|
type __VLS_WithSlots$1<T, S> = T & {
|
|
@@ -143,16 +354,205 @@ type __VLS_WithSlots$1<T, S> = T & {
|
|
|
143
354
|
};
|
|
144
355
|
//#endregion
|
|
145
356
|
//#region src/components/Tween.vue.d.ts
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
controlled: boolean;
|
|
149
|
-
parent: Animation | null;
|
|
150
|
-
ready: boolean;
|
|
357
|
+
type __VLS_Slots = {
|
|
358
|
+
default(props: DejaVueAnimationScopeProps): any;
|
|
151
359
|
};
|
|
152
|
-
type
|
|
153
|
-
|
|
360
|
+
type __VLS_ModelProps = {
|
|
361
|
+
'progress'?: number;
|
|
154
362
|
};
|
|
155
|
-
declare const __VLS_base:
|
|
363
|
+
declare const __VLS_base: import("vue").DefineComponent<(DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
364
|
+
progress?: number;
|
|
365
|
+
} & {
|
|
366
|
+
trigger?: unknown;
|
|
367
|
+
triggerAction?: TweenAction;
|
|
368
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
369
|
+
} & {
|
|
370
|
+
from: gsap.TweenVars;
|
|
371
|
+
to: gsap.TweenVars;
|
|
372
|
+
effect?: never;
|
|
373
|
+
effectOptions?: never;
|
|
374
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
375
|
+
progress?: number;
|
|
376
|
+
} & {
|
|
377
|
+
trigger?: unknown;
|
|
378
|
+
triggerAction?: TweenAction;
|
|
379
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
380
|
+
} & {
|
|
381
|
+
from: gsap.TweenVars;
|
|
382
|
+
to?: never;
|
|
383
|
+
effect?: never;
|
|
384
|
+
effectOptions?: never;
|
|
385
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
386
|
+
progress?: number;
|
|
387
|
+
} & {
|
|
388
|
+
trigger?: unknown;
|
|
389
|
+
triggerAction?: TweenAction;
|
|
390
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
391
|
+
} & {
|
|
392
|
+
from?: never;
|
|
393
|
+
to: gsap.TweenVars;
|
|
394
|
+
effect?: never;
|
|
395
|
+
effectOptions?: never;
|
|
396
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
397
|
+
progress?: number;
|
|
398
|
+
} & {
|
|
399
|
+
trigger?: unknown;
|
|
400
|
+
triggerAction?: TweenAction;
|
|
401
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
402
|
+
} & {
|
|
403
|
+
from?: never;
|
|
404
|
+
to?: never;
|
|
405
|
+
effect?: string;
|
|
406
|
+
effectOptions?: gsap.TweenVars;
|
|
407
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
408
|
+
progress?: number;
|
|
409
|
+
} & {
|
|
410
|
+
trigger?: never;
|
|
411
|
+
triggerAction?: never;
|
|
412
|
+
triggerOptions?: never;
|
|
413
|
+
} & {
|
|
414
|
+
from: gsap.TweenVars;
|
|
415
|
+
to: gsap.TweenVars;
|
|
416
|
+
effect?: never;
|
|
417
|
+
effectOptions?: never;
|
|
418
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
419
|
+
progress?: number;
|
|
420
|
+
} & {
|
|
421
|
+
trigger?: never;
|
|
422
|
+
triggerAction?: never;
|
|
423
|
+
triggerOptions?: never;
|
|
424
|
+
} & {
|
|
425
|
+
from: gsap.TweenVars;
|
|
426
|
+
to?: never;
|
|
427
|
+
effect?: never;
|
|
428
|
+
effectOptions?: never;
|
|
429
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
430
|
+
progress?: number;
|
|
431
|
+
} & {
|
|
432
|
+
trigger?: never;
|
|
433
|
+
triggerAction?: never;
|
|
434
|
+
triggerOptions?: never;
|
|
435
|
+
} & {
|
|
436
|
+
from?: never;
|
|
437
|
+
to: gsap.TweenVars;
|
|
438
|
+
effect?: never;
|
|
439
|
+
effectOptions?: never;
|
|
440
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
441
|
+
progress?: number;
|
|
442
|
+
} & {
|
|
443
|
+
trigger?: never;
|
|
444
|
+
triggerAction?: never;
|
|
445
|
+
triggerOptions?: never;
|
|
446
|
+
} & {
|
|
447
|
+
from?: never;
|
|
448
|
+
to?: never;
|
|
449
|
+
effect?: string;
|
|
450
|
+
effectOptions?: gsap.TweenVars;
|
|
451
|
+
} & __VLS_ModelProps), DejaVueAnimationInstance, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
|
|
452
|
+
complete: (...args: any[]) => void;
|
|
453
|
+
interrupt: (...args: any[]) => void;
|
|
454
|
+
repeat: (...args: any[]) => void;
|
|
455
|
+
reverseComplete: (...args: any[]) => void;
|
|
456
|
+
start: (...args: any[]) => void;
|
|
457
|
+
update: (...args: any[]) => void;
|
|
458
|
+
"update:progress": (value: number) => void;
|
|
459
|
+
}, string, import("vue").PublicProps, Readonly<(DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
460
|
+
progress?: number;
|
|
461
|
+
} & {
|
|
462
|
+
trigger?: unknown;
|
|
463
|
+
triggerAction?: TweenAction;
|
|
464
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
465
|
+
} & {
|
|
466
|
+
from: gsap.TweenVars;
|
|
467
|
+
to: gsap.TweenVars;
|
|
468
|
+
effect?: never;
|
|
469
|
+
effectOptions?: never;
|
|
470
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
471
|
+
progress?: number;
|
|
472
|
+
} & {
|
|
473
|
+
trigger?: unknown;
|
|
474
|
+
triggerAction?: TweenAction;
|
|
475
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
476
|
+
} & {
|
|
477
|
+
from: gsap.TweenVars;
|
|
478
|
+
to?: never;
|
|
479
|
+
effect?: never;
|
|
480
|
+
effectOptions?: never;
|
|
481
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
482
|
+
progress?: number;
|
|
483
|
+
} & {
|
|
484
|
+
trigger?: unknown;
|
|
485
|
+
triggerAction?: TweenAction;
|
|
486
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
487
|
+
} & {
|
|
488
|
+
from?: never;
|
|
489
|
+
to: gsap.TweenVars;
|
|
490
|
+
effect?: never;
|
|
491
|
+
effectOptions?: never;
|
|
492
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
493
|
+
progress?: number;
|
|
494
|
+
} & {
|
|
495
|
+
trigger?: unknown;
|
|
496
|
+
triggerAction?: TweenAction;
|
|
497
|
+
triggerOptions?: AnimationTriggerOptions;
|
|
498
|
+
} & {
|
|
499
|
+
from?: never;
|
|
500
|
+
to?: never;
|
|
501
|
+
effect?: string;
|
|
502
|
+
effectOptions?: gsap.TweenVars;
|
|
503
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
504
|
+
progress?: number;
|
|
505
|
+
} & {
|
|
506
|
+
trigger?: never;
|
|
507
|
+
triggerAction?: never;
|
|
508
|
+
triggerOptions?: never;
|
|
509
|
+
} & {
|
|
510
|
+
from: gsap.TweenVars;
|
|
511
|
+
to: gsap.TweenVars;
|
|
512
|
+
effect?: never;
|
|
513
|
+
effectOptions?: never;
|
|
514
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
515
|
+
progress?: number;
|
|
516
|
+
} & {
|
|
517
|
+
trigger?: never;
|
|
518
|
+
triggerAction?: never;
|
|
519
|
+
triggerOptions?: never;
|
|
520
|
+
} & {
|
|
521
|
+
from: gsap.TweenVars;
|
|
522
|
+
to?: never;
|
|
523
|
+
effect?: never;
|
|
524
|
+
effectOptions?: never;
|
|
525
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
526
|
+
progress?: number;
|
|
527
|
+
} & {
|
|
528
|
+
trigger?: never;
|
|
529
|
+
triggerAction?: never;
|
|
530
|
+
triggerOptions?: never;
|
|
531
|
+
} & {
|
|
532
|
+
from?: never;
|
|
533
|
+
to: gsap.TweenVars;
|
|
534
|
+
effect?: never;
|
|
535
|
+
effectOptions?: never;
|
|
536
|
+
} & __VLS_ModelProps) | (DejaVueAnimationComponentProps & AnimationNestableChild & {
|
|
537
|
+
progress?: number;
|
|
538
|
+
} & {
|
|
539
|
+
trigger?: never;
|
|
540
|
+
triggerAction?: never;
|
|
541
|
+
triggerOptions?: never;
|
|
542
|
+
} & {
|
|
543
|
+
from?: never;
|
|
544
|
+
to?: never;
|
|
545
|
+
effect?: string;
|
|
546
|
+
effectOptions?: gsap.TweenVars;
|
|
547
|
+
} & __VLS_ModelProps)> & Readonly<{
|
|
548
|
+
"onUpdate:progress"?: ((value: number) => any) | undefined;
|
|
549
|
+
onComplete?: ((...args: any[]) => any) | undefined;
|
|
550
|
+
onInterrupt?: ((...args: any[]) => any) | undefined;
|
|
551
|
+
onRepeat?: ((...args: any[]) => any) | undefined;
|
|
552
|
+
onReverseComplete?: ((...args: any[]) => any) | undefined;
|
|
553
|
+
onStart?: ((...args: any[]) => any) | undefined;
|
|
554
|
+
onUpdate?: ((...args: any[]) => any) | undefined;
|
|
555
|
+
}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
|
|
156
556
|
declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
|
|
157
557
|
declare const _default$3: typeof __VLS_export;
|
|
158
558
|
type __VLS_WithSlots<T, S> = T & {
|
|
@@ -161,4 +561,4 @@ type __VLS_WithSlots<T, S> = T & {
|
|
|
161
561
|
};
|
|
162
562
|
};
|
|
163
563
|
//#endregion
|
|
164
|
-
export { ANIMATION_EVENTS, Animation,
|
|
564
|
+
export { ANIMATION_EVENTS, Animation, type AnimationChild, type AnimationComposeDefinition, AnimationControls, type AnimationDirection, type AnimationEvent, type AnimationEventEmitter, type AnimationNestableChild, AnimationNestingOptions, AnimationNestingTarget, AnimationScopeOptions, type AnimationTriggerOptions, type ControllableAnimation, type DejaVueAnimationComponentProps, type DejaVueAnimationExposed, type DejaVueAnimationInstance, type DejaVueAnimationParent, type DejaVueAnimationScopeProps, type DejaVueComponent, type DejaVueMarkerExposed, type DejaVueMarkerInstance, type DejaVueMarkerScopeProps, type DejaVueNode, type DejaVueSplitTextExposed, type DejaVueSplitTextInstance, type DejaVueSplitTextScopeProps, _default as Marker, type NonEmptyArray, type PlainObject, _default$1 as SplitText, SplitTextOptions, _default$2 as Timeline, _default$3 as Tween, type TweenAction, type TweenDefinition, type WrappableComponent, applyTimelineTotalDuration, cloneObject, dejaVueParentInstance, getScrollTriggerToggleActionByEvent, isEmptyTarget, isObject, patchArray, patchObject, resolveChildrenTweenTarget, resolveTimelinePosition, stripScrollTriggerVars, syncData, toNonEmptyArray, useAnimationControls, useAnimationNesting, useAnimationScope, useSplitText, useStableObjectProp, useTweenVars };
|