@egjs/flicking 4.11.3-beta.2 → 4.11.3-beta.4

package/declaration/renderer/strategy/index.d.ts

@@ -1,5 +1,5 @@
-import RenderingStrategy from "./RenderingStrategy";
-import NormalRenderingStrategy, { NormalRenderingStrategyOptions } from "./NormalRenderingStrategy";
-import VirtualRenderingStrategy from "./VirtualRenderingStrategy";
-export { NormalRenderingStrategy, VirtualRenderingStrategy };
-export type { RenderingStrategy, NormalRenderingStrategyOptions };
+import RenderingStrategy from "./RenderingStrategy";
+import NormalRenderingStrategy, { NormalRenderingStrategyOptions } from "./NormalRenderingStrategy";
+import VirtualRenderingStrategy from "./VirtualRenderingStrategy";
+export { NormalRenderingStrategy, VirtualRenderingStrategy };
+export type { RenderingStrategy, NormalRenderingStrategyOptions };

package/declaration/type/event.d.ts

@@ -1,88 +1,88 @@
-import { OnChange, OnFinish, OnHold, OnRelease } from "@egjs/axes";
-import { ComponentEvent } from "@egjs/component";
-import Flicking from "../Flicking";
-import Panel from "../core/panel/Panel";
-import { EVENTS, DIRECTION } from "../const/external";
-import { ValueOf } from "../type/internal";
-export declare type ReadyEvent<T extends Flicking = Flicking> = ComponentEvent<{}, typeof EVENTS["READY"], T>;
-export interface BeforeResizeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["BEFORE_RESIZE"], T> {
-    width: number;
-    height: number;
-    element: HTMLElement;
-}
-export interface AfterResizeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["AFTER_RESIZE"], T> {
-    width: number;
-    height: number;
-    prev: {
-        width: number;
-        height: number;
-    };
-    sizeChanged: boolean;
-    element: HTMLElement;
-}
-export interface HoldStartEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["HOLD_START"], T> {
-    axesEvent: OnHold;
-}
-export interface HoldEndEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["HOLD_END"], T> {
-    axesEvent: OnRelease;
-}
-export interface MoveStartEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE_START"], T> {
-    isTrusted: boolean;
-    holding: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-    axesEvent: OnChange;
-}
-export interface MoveEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE"], T> {
-    isTrusted: boolean;
-    holding: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-    axesEvent: OnChange;
-}
-export interface MoveEndEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE_END"], T> {
-    isTrusted: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-    axesEvent: OnFinish;
-}
-export interface WillChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["WILL_CHANGE"], T> {
-    index: number;
-    panel: Panel;
-    isTrusted: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-}
-export interface ChangedEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["CHANGED"], T> {
-    index: number;
-    panel: Panel;
-    prevIndex: number;
-    prevPanel: Panel | null;
-    isTrusted: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-}
-export interface WillRestoreEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["WILL_RESTORE"], T> {
-    index: number;
-    panel: Panel;
-    isTrusted: boolean;
-    direction: ValueOf<typeof DIRECTION>;
-}
-export interface RestoredEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["RESTORED"], T> {
-    isTrusted: boolean;
-}
-export interface SelectEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["SELECT"], T> {
-    index: number;
-    panel: Panel;
-    direction: ValueOf<typeof DIRECTION> | null;
-}
-export interface NeedPanelEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["NEED_PANEL"], T> {
-    direction: Exclude<ValueOf<typeof DIRECTION>, null>;
-}
-export interface VisibleChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["VISIBLE_CHANGE"], T> {
-    added: Panel[];
-    removed: Panel[];
-    visiblePanels: Panel[];
-}
-export interface ReachEdgeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["REACH_EDGE"], T> {
-    direction: ValueOf<typeof DIRECTION>;
-}
-export interface PanelChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["PANEL_CHANGE"], T> {
-    added: Panel[];
-    removed: Panel[];
-}
+import { OnChange, OnFinish, OnHold, OnRelease } from "@egjs/axes";
+import { ComponentEvent } from "@egjs/component";
+import Flicking from "../Flicking";
+import Panel from "../core/panel/Panel";
+import { EVENTS, DIRECTION } from "../const/external";
+import { ValueOf } from "../type/internal";
+export declare type ReadyEvent<T extends Flicking = Flicking> = ComponentEvent<{}, typeof EVENTS["READY"], T>;
+export interface BeforeResizeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["BEFORE_RESIZE"], T> {
+    width: number;
+    height: number;
+    element: HTMLElement;
+}
+export interface AfterResizeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["AFTER_RESIZE"], T> {
+    width: number;
+    height: number;
+    prev: {
+        width: number;
+        height: number;
+    };
+    sizeChanged: boolean;
+    element: HTMLElement;
+}
+export interface HoldStartEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["HOLD_START"], T> {
+    axesEvent: OnHold;
+}
+export interface HoldEndEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["HOLD_END"], T> {
+    axesEvent: OnRelease;
+}
+export interface MoveStartEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE_START"], T> {
+    isTrusted: boolean;
+    holding: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+    axesEvent: OnChange;
+}
+export interface MoveEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE"], T> {
+    isTrusted: boolean;
+    holding: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+    axesEvent: OnChange;
+}
+export interface MoveEndEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["MOVE_END"], T> {
+    isTrusted: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+    axesEvent: OnFinish;
+}
+export interface WillChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["WILL_CHANGE"], T> {
+    index: number;
+    panel: Panel;
+    isTrusted: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+}
+export interface ChangedEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["CHANGED"], T> {
+    index: number;
+    panel: Panel;
+    prevIndex: number;
+    prevPanel: Panel | null;
+    isTrusted: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+}
+export interface WillRestoreEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["WILL_RESTORE"], T> {
+    index: number;
+    panel: Panel;
+    isTrusted: boolean;
+    direction: ValueOf<typeof DIRECTION>;
+}
+export interface RestoredEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["RESTORED"], T> {
+    isTrusted: boolean;
+}
+export interface SelectEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["SELECT"], T> {
+    index: number;
+    panel: Panel;
+    direction: ValueOf<typeof DIRECTION> | null;
+}
+export interface NeedPanelEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["NEED_PANEL"], T> {
+    direction: Exclude<ValueOf<typeof DIRECTION>, null>;
+}
+export interface VisibleChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["VISIBLE_CHANGE"], T> {
+    added: Panel[];
+    removed: Panel[];
+    visiblePanels: Panel[];
+}
+export interface ReachEdgeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["REACH_EDGE"], T> {
+    direction: ValueOf<typeof DIRECTION>;
+}
+export interface PanelChangeEvent<T extends Flicking = Flicking> extends ComponentEvent<{}, typeof EVENTS["PANEL_CHANGE"], T> {
+    added: Panel[];
+    removed: Panel[];
+}

package/declaration/type/external.d.ts

@@ -1,31 +1,31 @@
-import Flicking from "../Flicking";
-import { SnapControlOptions, FreeControlOptions, StrictControlOptions } from "../control";
-import { MOVE_TYPE } from "../const/external";
-import { ValueOf } from "../type/internal";
-export declare type ElementLike = string | HTMLElement;
-export interface Plugin {
-    init(flicking: Flicking): void;
-    destroy(): void;
-    update(flicking: Flicking): void;
-}
-export interface Status {
-    index?: number;
-    position?: {
-        panel: number;
-        progressInPanel: number;
-    };
-    visibleOffset?: number;
-    panels: Array<{
-        index: number;
-        html?: string;
-    }>;
-}
-export declare type MoveTypeOptions<T extends ValueOf<typeof MOVE_TYPE>> = T extends typeof MOVE_TYPE.SNAP ? [T] | [T, Partial<SnapControlOptions>] : T extends typeof MOVE_TYPE.FREE_SCROLL ? [T] | [T, Partial<FreeControlOptions>] : T extends typeof MOVE_TYPE.STRICT ? [T] | [T, Partial<StrictControlOptions>] : [T];
-export interface ControlParams {
-    range: {
-        min: number;
-        max: number;
-    };
-    position: number;
-    circular: boolean;
-}
+import Flicking from "../Flicking";
+import { SnapControlOptions, FreeControlOptions, StrictControlOptions } from "../control";
+import { MOVE_TYPE } from "../const/external";
+import { ValueOf } from "../type/internal";
+export declare type ElementLike = string | HTMLElement;
+export interface Plugin {
+    init(flicking: Flicking): void;
+    destroy(): void;
+    update(flicking: Flicking): void;
+}
+export interface Status {
+    index?: number;
+    position?: {
+        panel: number;
+        progressInPanel: number;
+    };
+    visibleOffset?: number;
+    panels: Array<{
+        index: number;
+        html?: string;
+    }>;
+}
+export declare type MoveTypeOptions<T extends ValueOf<typeof MOVE_TYPE>> = T extends typeof MOVE_TYPE.SNAP ? [T] | [T, Partial<SnapControlOptions>] : T extends typeof MOVE_TYPE.FREE_SCROLL ? [T] | [T, Partial<FreeControlOptions>] : T extends typeof MOVE_TYPE.STRICT ? [T] | [T, Partial<StrictControlOptions>] : [T];
+export interface ControlParams {
+    range: {
+        min: number;
+        max: number;
+    };
+    position: number;
+    circular: boolean;
+}

package/declaration/type/internal.d.ts

@@ -1,13 +1,13 @@
-export declare type ValueOf<T> = T[keyof T];
-export declare type LiteralUnion<T extends U, U = string> = T | (Pick<U, never> & {
-    _?: never;
-});
-export interface ArrayLike<T> {
-    [index: number]: T;
-    length: number;
-}
-export declare type Unique<T, U> = Pick<T, Exclude<keyof T, keyof U>>;
-export declare type MergeObject<T, U> = {
-    [K in keyof T & keyof U]: T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? Merged<T[K], U[K]> : T[K] : T[K];
-};
-export declare type Merged<From, To> = Unique<From, To> & Unique<To, From> & MergeObject<From, To>;
+export declare type ValueOf<T> = T[keyof T];
+export declare type LiteralUnion<T extends U, U = string> = T | (Pick<U, never> & {
+    _?: never;
+});
+export interface ArrayLike<T> {
+    [index: number]: T;
+    length: number;
+}
+export declare type Unique<T, U> = Pick<T, Exclude<keyof T, keyof U>>;
+export declare type MergeObject<T, U> = {
+    [K in keyof T & keyof U]: T[K] extends Record<string, unknown> ? U[K] extends Record<string, unknown> ? Merged<T[K], U[K]> : T[K] : T[K];
+};
+export declare type Merged<From, To> = Unique<From, To> & Unique<To, From> & MergeObject<From, To>;

package/declaration/utils.d.ts

@@ -1,45 +1,45 @@
-import Flicking, { FlickingOptions } from "./Flicking";
-import { ALIGN, DIRECTION } from "./const/external";
-import { LiteralUnion, Merged, ValueOf } from "./type/internal";
-import { ElementLike } from "./type/external";
-export declare const merge: <From extends object, To extends object>(target: From, ...sources: To[]) => Merged<From, To>;
-export declare const getElement: (el: HTMLElement | string | null, parent?: HTMLElement) => HTMLElement;
-export declare const checkExistence: (value: any, nameOnErrMsg: string) => void;
-export declare const clamp: (x: number, min: number, max: number) => number;
-export declare const getFlickingAttached: (val: Flicking | null) => Flicking;
-export declare const toArray: <T>(iterable: ArrayLike<T>) => T[];
-export declare const parseAlign: (align: LiteralUnion<ValueOf<typeof ALIGN>> | number, size: number) => number;
-export declare const parseBounce: (bounce: FlickingOptions["bounce"], size: number) => number[];
-export declare const parseArithmeticSize: (cssValue: number | string, base: number) => number | null;
-export declare const parseArithmeticExpression: (cssValue: number | string) => {
-    percentage: number;
-    absolute: number;
-} | null;
-export declare const parseCSSSizeValue: (val: string | number) => string;
-export declare const parsePanelAlign: (align: FlickingOptions["align"]) => string | number;
-export declare const getDirection: (start: number, end: number) => ValueOf<typeof DIRECTION>;
-export declare const parseElement: (element: ElementLike | ElementLike[]) => HTMLElement[];
-export declare const getMinusCompensatedIndex: (idx: number, max: number) => number;
-export declare const includes: <T>(array: T[], target: any) => target is T;
-export declare const isString: (val: any) => val is string;
-export declare const circulatePosition: (pos: number, min: number, max: number) => number;
-export declare const find: <T>(array: T[], checker: (val: T) => boolean) => T;
-export declare const findRight: <T>(array: T[], checker: (val: T) => boolean) => T;
-export declare const findIndex: <T>(array: T[], checker: (val: T) => boolean) => number;
-export declare const getProgress: (pos: number, prev: number, next: number) => number;
-export declare const getStyle: (el: HTMLElement) => CSSStyleDeclaration;
-export declare const setSize: (el: HTMLElement, { width, height }: Partial<{
-    width: number | string;
-    height: number | string;
-}>) => void;
-export declare const isBetween: (val: number, min: number, max: number) => boolean;
-export declare const circulateIndex: (index: number, max: number) => number;
-export declare const range: (end: number) => number[];
-export declare const getElementSize: ({ el, horizontal, useFractionalSize, useOffset, style }: {
-    el: HTMLElement;
-    horizontal: boolean;
-    useFractionalSize: boolean;
-    useOffset: boolean;
-    style: CSSStyleDeclaration;
-}) => number;
-export declare const setPrototypeOf: (o: any, proto: object) => any;
+import Flicking, { FlickingOptions } from "./Flicking";
+import { ALIGN, DIRECTION } from "./const/external";
+import { LiteralUnion, Merged, ValueOf } from "./type/internal";
+import { ElementLike } from "./type/external";
+export declare const merge: <From extends object, To extends object>(target: From, ...sources: To[]) => Merged<From, To>;
+export declare const getElement: (el: HTMLElement | string | null, parent?: HTMLElement) => HTMLElement;
+export declare const checkExistence: (value: any, nameOnErrMsg: string) => void;
+export declare const clamp: (x: number, min: number, max: number) => number;
+export declare const getFlickingAttached: (val: Flicking | null) => Flicking;
+export declare const toArray: <T>(iterable: ArrayLike<T>) => T[];
+export declare const parseAlign: (align: LiteralUnion<ValueOf<typeof ALIGN>> | number, size: number) => number;
+export declare const parseBounce: (bounce: FlickingOptions["bounce"], size: number) => number[];
+export declare const parseArithmeticSize: (cssValue: number | string, base: number) => number | null;
+export declare const parseArithmeticExpression: (cssValue: number | string) => {
+    percentage: number;
+    absolute: number;
+} | null;
+export declare const parseCSSSizeValue: (val: string | number) => string;
+export declare const parsePanelAlign: (align: FlickingOptions["align"]) => string | number;
+export declare const getDirection: (start: number, end: number) => ValueOf<typeof DIRECTION>;
+export declare const parseElement: (element: ElementLike | ElementLike[]) => HTMLElement[];
+export declare const getMinusCompensatedIndex: (idx: number, max: number) => number;
+export declare const includes: <T>(array: T[], target: any) => target is T;
+export declare const isString: (val: any) => val is string;
+export declare const circulatePosition: (pos: number, min: number, max: number) => number;
+export declare const find: <T>(array: T[], checker: (val: T) => boolean) => T;
+export declare const findRight: <T>(array: T[], checker: (val: T) => boolean) => T;
+export declare const findIndex: <T>(array: T[], checker: (val: T) => boolean) => number;
+export declare const getProgress: (pos: number, prev: number, next: number) => number;
+export declare const getStyle: (el: HTMLElement) => CSSStyleDeclaration;
+export declare const setSize: (el: HTMLElement, { width, height }: Partial<{
+    width: number | string;
+    height: number | string;
+}>) => void;
+export declare const isBetween: (val: number, min: number, max: number) => boolean;
+export declare const circulateIndex: (index: number, max: number) => number;
+export declare const range: (end: number) => number[];
+export declare const getElementSize: ({ el, horizontal, useFractionalSize, useOffset, style }: {
+    el: HTMLElement;
+    horizontal: boolean;
+    useFractionalSize: boolean;
+    useOffset: boolean;
+    style: CSSStyleDeclaration;
+}) => number;
+export declare const setPrototypeOf: (o: any, proto: object) => any;

package/dist/flicking.cjs.js

@@ -4,7 +4,7 @@ name: @egjs/flicking
 license: MIT
 author: NAVER Corp.
 repository: https://github.com/naver/egjs-flicking
-version: 4.11.3-beta.2
+version: 4.11.3-beta.4
 */
 'use strict';
 
@@ -12,7 +12,7 @@ var Component = require('@egjs/component');
 var Axes = require('@egjs/axes');
 var ImReady = require('@egjs/imready');
 
-/******************************************************************************
+/*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
 Permission to use, copy, modify, and/or distribute this software for any
@@ -26,7 +26,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise */
 
 var extendStatics = function (d, b) {
   extendStatics = Object.setPrototypeOf || {
@@ -111,7 +111,7 @@ function __generator(thisArg, body) {
   }
   function step(op) {
     if (f) throw new TypeError("Generator is already executing.");
-    while (g && (g = 0, op[0] && (_ = 0)), _) try {
+    while (_) try {
       if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
       if (y = 0, t) op = [op[0] & 2, t.value];
       switch (op[0]) {
@@ -215,10 +215,6 @@ function __spread() {
   for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
   return ar;
 }
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
 
 /*
  * Copyright (c) 2015 NAVER Corp.
@@ -2868,7 +2864,7 @@ var SnapControl = /*#__PURE__*/function (_super) {
     if (!activeAnchor || !anchorAtCamera) {
       return Promise.reject(new FlickingError(MESSAGE.POSITION_NOT_REACHABLE(position), CODE.POSITION_NOT_REACHABLE));
     }
-    var snapThreshold = this._calcSnapThreshold(position, activeAnchor);
+    var snapThreshold = this._calcSnapThreshold(flicking.threshold, position, activeAnchor);
     var posDelta = flicking.animating ? state.delta : position - camera.position;
     var absPosDelta = Math.abs(posDelta);
     var snapDelta = axesEvent && axesEvent.delta[POSITION_KEY] !== 0 ? Math.abs(axesEvent.delta[POSITION_KEY]) : absPosDelta;
@@ -2955,7 +2951,7 @@ var SnapControl = /*#__PURE__*/function (_super) {
     var adjacentAnchor = (_a = posDelta > 0 ? camera.getNextAnchor(anchorAtCamera) : camera.getPrevAnchor(anchorAtCamera)) !== null && _a !== void 0 ? _a : anchorAtCamera;
     return adjacentAnchor;
   };
-  __proto._calcSnapThreshold = function (position, activeAnchor) {
+  __proto._calcSnapThreshold = function (threshold, position, activeAnchor) {
     var isNextDirection = position > activeAnchor.position;
     var panel = activeAnchor.panel;
     var panelSize = panel.size;
@@ -2966,7 +2962,7 @@ var SnapControl = /*#__PURE__*/function (_super) {
      * |<------>|<------------>|
      * [        |<-Anchor      ]
      */
-    return isNextDirection ? panelSize - alignPos + panel.margin.next : alignPos + panel.margin.prev;
+    return Math.max(threshold, isNextDirection ? panelSize - alignPos + panel.margin.next : alignPos + panel.margin.prev);
   };
   return SnapControl;
 }(Control);
@@ -4171,11 +4167,13 @@ var Camera = /*#__PURE__*/function () {
    * @return {AnchorPoint | null}
    */
   __proto.findActiveAnchor = function () {
+    var _a;
     var flicking = getFlickingAttached(this._flicking);
-    var activeIndex = flicking.control.activeIndex;
-    return find(this._anchors, function (anchor) {
-      return anchor.panel.index === activeIndex;
-    });
+    var activePanel = flicking.control.activePanel;
+    if (!activePanel) return null;
+    return (_a = find(this._anchors, function (anchor) {
+      return anchor.panel.index === activePanel.index;
+    })) !== null && _a !== void 0 ? _a : this.findNearestAnchor(activePanel.position);
   };
   /**
    * Clamp the given position between camera's range
@@ -7582,6 +7580,10 @@ var Flicking = /*#__PURE__*/function (_super) {
             return [4 /*yield*/, renderer.forceRenderAllPanels()];
           case 1:
             _a.sent(); // Render all panel elements, to update sizes
+            if (!this._initialized) {
+              return [2 /*return*/];
+            }
+
             renderer.updatePanelSize();
             camera.updateAlignPos();
             camera.updateRange();
@@ -7592,6 +7594,10 @@ var Flicking = /*#__PURE__*/function (_super) {
             return [4 /*yield*/, renderer.render()];
           case 2:
             _a.sent();
+            if (!this._initialized) {
+              return [2 /*return*/];
+            }
+
             if (control.animating) ; else {
               control.updatePosition(prevProgressInPanel);
               control.updateInput();
@@ -7828,7 +7834,7 @@ var Flicking = /*#__PURE__*/function (_super) {
    * Flicking.VERSION;  // ex) 4.0.0
    * ```
    */
-  Flicking.VERSION = "4.11.3-beta.2";
+  Flicking.VERSION = "4.11.3-beta.4";
   return Flicking;
 }(Component);