@egjs/vue3-flicking 4.3.1 → 4.4.3

package/declaration/Flicking.d.ts

@@ -1,103 +1,6 @@
-import { Vue, VueConstructor } from "vue-class-component";
-import { VNode } from "vue";
-import VanillaFlicking, { 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: string;
-    options: import("vue-class-component").WithDefault<Partial<FlickingOptions>>;
-    plugins: import("vue-class-component").WithDefault<Plugin[]>;
-    status: Status;
-}
-declare const Flicking_base: VueConstructor<{
-    $: import("vue").ComponentInternalInstance;
-    $data: {};
-    $props: Partial<{}> & Pick<import("vue-class-component").PublicProps, "key" | "ref" | "onVnodeBeforeMount" | "onVnodeMounted" | "onVnodeBeforeUpdate" | "onVnodeUpdated" | "onVnodeBeforeUnmount" | "onVnodeUnmounted" | "class" | "style">;
-    $attrs: Record<string, unknown>;
-    $refs: Record<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>> & Pick<import("vue-class-component").ExtractProps<FlickingProps> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "firstPanelSize" | "status" | "key" | "ref" | "onVnodeBeforeMount" | "onVnodeMounted" | "onVnodeBeforeUpdate" | "onVnodeUpdated" | "onVnodeBeforeUnmount" | "onVnodeUnmounted" | "class" | "style">;
-    $attrs: Record<string, unknown>;
-    $refs: Record<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 {
-    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;
-}
-interface Flicking extends VanillaFlicking, VueConstructor<Vue & FlickingProps> {
+import VanillaFlicking from "@egjs/flicking";
+import { VueFlicking } from "./types";
+declare const Flicking: VueFlicking;
+interface Flicking extends VueFlicking, VanillaFlicking {
 }
 export default Flicking;

package/declaration/FlickingProps.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from "vue";
+import { FlickingOptions, Plugin, Status } from "@egjs/flicking";
+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

@@ -0,0 +1,12 @@
+import { ElementProvider } from "@egjs/flicking";
+import VuePanel from "./VuePanel";
+declare class VueElementProvider implements ElementProvider {
+    private _el;
+    private _cachedElement;
+    get rendered(): boolean;
+    get element(): HTMLElement;
+    constructor(el: VuePanel);
+    show(): void;
+    hide(): void;
+}
+export default VueElementProvider;

package/declaration/VuePanel.d.ts

@@ -1,9 +1,7 @@
-import { ExternalPanel } from "@egjs/flicking";
-import VuePanelComponent from "./VuePanelComponent";
-declare class VuePanel extends ExternalPanel<VuePanelComponent> {
-    get element(): HTMLElement;
-    get rendered(): boolean;
-    markForShow(): void;
-    markForHide(): void;
+declare const VuePanel: import("vue").DefineComponent<{}, {}, {
+    hide: boolean;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
+declare type VuePanelType = InstanceType<typeof VuePanel>;
+interface VuePanel extends VuePanelType {
 }
 export default VuePanel;

package/declaration/VueRenderer.d.ts

@@ -1,16 +1,15 @@
 import { ExternalRenderer, PanelOptions, RendererOptions } from "@egjs/flicking";
 import VueFlicking from "./Flicking";
 import VuePanel from "./VuePanel";
-import VuePanelComponent from "./VuePanelComponent";
 export interface VueRendererOptions extends RendererOptions {
     vueFlicking: VueFlicking;
 }
 declare class VueRenderer extends ExternalRenderer {
-    protected _vueFlicking: VueFlicking;
+    private _vueFlicking;
     constructor(options: VueRendererOptions);
     render(): Promise<void>;
     forceRenderAllPanels(): Promise<void>;
     protected _collectPanels(): void;
-    protected _createPanel(externalComponent: VuePanelComponent, options: PanelOptions): VuePanel;
+    protected _createPanel(externalComponent: VuePanel, options: PanelOptions): import("@egjs/flicking/declaration/core/panel/Panel").default;
 }
 export default VueRenderer;

package/declaration/index.d.ts

@@ -1,3 +1,3 @@
 import Flicking from "./Flicking";
-export default Flicking;
 export * from "@egjs/flicking";
+export default Flicking;

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 {};