@egjs/vue3-flicking 4.4.1 → 4.5.1

package/declaration/Flicking.d.ts

@@ -1,110 +1,6 @@
-import { VNode } from "vue";
-import { Vue, VueConstructor } from "vue-class-component";
-import Component from "@egjs/component";
 import VanillaFlicking from "@egjs/flicking";
-import FlickingProps from "./FlickingProps";
-declare const Flicking_base: VueConstructor<{
-    $: import("vue").ComponentInternalInstance;
-    $data: {};
-    $props: Partial<{}> & Omit<import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>;
-    $attrs: {
-        [x: string]: unknown;
-    };
-    $refs: {
-        [x: string]: unknown;
-    };
-    $slots: Readonly<{
-        [name: string]: import("vue").Slot;
-    }>;
-    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
-    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
-    $emit: (event: string, ...args: any[]) => void;
-    $el: any;
-    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}> & {
-        beforeCreate?: (() => void) | (() => void)[];
-        created?: (() => void) | (() => void)[];
-        beforeMount?: (() => void) | (() => void)[];
-        mounted?: (() => void) | (() => void)[];
-        beforeUpdate?: (() => void) | (() => void)[];
-        updated?: (() => void) | (() => void)[];
-        activated?: (() => void) | (() => void)[];
-        deactivated?: (() => void) | (() => void)[];
-        beforeDestroy?: (() => void) | (() => void)[];
-        beforeUnmount?: (() => void) | (() => void)[];
-        destroyed?: (() => void) | (() => void)[];
-        unmounted?: (() => void) | (() => void)[];
-        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
-    };
-    $forceUpdate: () => void;
-    $nextTick: typeof import("vue").nextTick;
-    $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
-} & import("vue").ShallowUnwrapRef<{}> & {} & {} & import("vue").ComponentCustomProperties & import("vue-class-component").ClassComponentHooks & {
-    $: import("vue").ComponentInternalInstance;
-    $data: {};
-    $props: Partial<import("vue-class-component").ExtractDefaultProps<FlickingProps>> & Omit<import("vue-class-component").ExtractProps<FlickingProps> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, import("vue-class-component").DefaultKeys<FlickingProps>>;
-    $attrs: {
-        [x: string]: unknown;
-    };
-    $refs: {
-        [x: string]: unknown;
-    };
-    $slots: Readonly<{
-        [name: string]: import("vue").Slot;
-    }>;
-    $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
-    $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
-    $emit: (event: string, ...args: any[]) => void;
-    $el: any;
-    $options: import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}> & {
-        beforeCreate?: (() => void) | (() => void)[];
-        created?: (() => void) | (() => void)[];
-        beforeMount?: (() => void) | (() => void)[];
-        mounted?: (() => void) | (() => void)[];
-        beforeUpdate?: (() => void) | (() => void)[];
-        updated?: (() => void) | (() => void)[];
-        activated?: (() => void) | (() => void)[];
-        deactivated?: (() => void) | (() => void)[];
-        beforeDestroy?: (() => void) | (() => void)[];
-        beforeUnmount?: (() => void) | (() => void)[];
-        destroyed?: (() => void) | (() => void)[];
-        unmounted?: (() => void) | (() => void)[];
-        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
-        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
-    };
-    $forceUpdate: () => void;
-    $nextTick: typeof import("vue").nextTick;
-    $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
-} & import("vue-class-component").ExtractProps<FlickingProps>>;
-declare class Flicking extends Flicking_base {
-    readonly renderEmitter: Component<{
-        render: void;
-    }>;
-    private vanillaFlicking;
-    private pluginsDiffer;
-    private slotDiffer;
-    private diffResult?;
-    mounted(): void;
-    beforeDestroy(): void;
-    beforeMount(): void;
-    beforeUpdate(): void;
-    updated(): void;
-    render(): VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>;
-    getSlots(): VNode<import("vue").RendererNode, import("vue").RendererElement, {
-        [key: string]: any;
-    }>[];
-    getElementVNodes(slot: VNode, childSlots?: VNode[]): VNode[];
-    private bindEvents;
-    private checkPlugins;
-    private fillKeys;
-    private getChildren;
-    private getPanels;
-    private getVirtualPanels;
-}
-interface Flicking extends VanillaFlicking, VueConstructor<Vue & FlickingProps> {
+import { VueFlicking } from "./types";
+declare const Flicking: VueFlicking;
+interface Flicking extends VueFlicking, VanillaFlicking {
 }
 export default Flicking;

package/declaration/FlickingProps.d.ts

@@ -1,11 +1,38 @@
+import { PropType } from "vue";
 import { FlickingOptions, Plugin, Status } from "@egjs/flicking";
-declare class FlickingProps {
-    viewportTag: import("vue-class-component").WithDefault<string>;
-    cameraTag: import("vue-class-component").WithDefault<string>;
-    hideBeforeInit: import("vue-class-component").WithDefault<boolean>;
-    firstPanelSize: import("vue-class-component").WithDefault<string>;
-    options: import("vue-class-component").WithDefault<Partial<FlickingOptions>>;
-    plugins: import("vue-class-component").WithDefault<Plugin[]>;
-    status: import("vue-class-component").WithDefault<Status>;
-}
-export default FlickingProps;
+declare const _default: {
+    viewportTag: {
+        type: StringConstructor;
+        default: string;
+        required: boolean;
+    };
+    cameraTag: {
+        type: StringConstructor;
+        default: string;
+        required: boolean;
+    };
+    hideBeforeInit: {
+        type: BooleanConstructor;
+        default: boolean;
+        required: boolean;
+    };
+    firstPanelSize: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    options: {
+        type: () => Partial<FlickingOptions>;
+        default: () => {};
+        required: boolean;
+    };
+    plugins: {
+        type: PropType<Plugin[]>;
+        default: () => any[];
+        required: boolean;
+    };
+    status: {
+        type: PropType<Status>;
+        required: boolean;
+    };
+};
+export default _default;

package/declaration/VueElementProvider.d.ts

@@ -1,6 +1,6 @@
-import { ExternalElementProvider } from "@egjs/flicking";
+import { ElementProvider } from "@egjs/flicking";
 import VuePanel from "./VuePanel";
-declare class VueElementProvider implements ExternalElementProvider {
+declare class VueElementProvider implements ElementProvider {
     private _el;
     private _cachedElement;
     get rendered(): boolean;

package/declaration/VuePanel.d.ts

@@ -1,6 +1,7 @@
-import { Vue } from "vue-class-component";
-declare class VuePanel extends Vue {
+declare const VuePanel: import("vue").DefineComponent<{}, {}, {
     hide: boolean;
-    render(): any;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+declare type VuePanelType = InstanceType<typeof VuePanel>;
+interface VuePanel extends VuePanelType {
 }
 export default VuePanel;

package/declaration/types.d.ts

@@ -0,0 +1,44 @@
+import { ComponentOptionsMixin, DefineComponent, VNode } from "vue";
+import VanillaFlicking, { Plugin, Status, FlickingOptions, FlickingEvents } from "@egjs/flicking";
+import Component from "@egjs/component";
+import ListDiffer, { DiffResult } from "@egjs/list-differ";
+import FlickingProps from "./FlickingProps";
+export interface FlickingData {
+    renderEmitter: Component<{
+        render: void;
+    }>;
+    vanillaFlicking: VanillaFlicking;
+    pluginsDiffer: ListDiffer<Plugin>;
+    slotDiffer: ListDiffer<VNode>;
+    diffResult: DiffResult<VNode> | null;
+}
+declare type VueFlickingEmits = {
+    [key in keyof FlickingEvents]: (evt: FlickingEvents[key]) => any;
+};
+export declare type VueFlicking = DefineComponent<typeof FlickingProps, unknown, FlickingData, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, VueFlickingEmits, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    viewportTag?: unknown;
+    cameraTag?: unknown;
+    hideBeforeInit?: unknown;
+    firstPanelSize?: unknown;
+    options?: unknown;
+    plugins?: unknown;
+    status?: unknown;
+} & {
+    viewportTag: string;
+    cameraTag: string;
+    hideBeforeInit: boolean;
+    options: Partial<FlickingOptions>;
+    plugins: Plugin[];
+} & {
+    firstPanelSize?: string;
+    status?: Status;
+} & {
+    [K in keyof VueFlickingEmits as `on${Capitalize<K>}`]?: VueFlickingEmits[K];
+}>, {
+    viewportTag: string;
+    cameraTag: string;
+    hideBeforeInit: boolean;
+    options: Partial<FlickingOptions>;
+    plugins: Plugin[];
+}>;
+export {};