@egjs/flicking 4.3.1 → 4.5.0

package/declaration/renderer/Renderer.d.ts

@@ -1,40 +1,45 @@
 import Flicking, { FlickingOptions } from "../Flicking";
 import Panel, { PanelOptions } from "../core/panel/Panel";
+import RenderingStrategy from "./strategy/RenderingStrategy";
 export interface RendererOptions {
-    align: FlickingOptions["align"];
+    align?: FlickingOptions["align"];
+    strategy: RenderingStrategy;
 }
 declare abstract class Renderer {
     protected _flicking: Flicking | null;
     protected _panels: Panel[];
-    protected _align: RendererOptions["align"];
+    protected _align: NonNullable<RendererOptions["align"]>;
+    protected _strategy: RendererOptions["strategy"];
     get panels(): Panel[];
     get panelCount(): number;
-    get align(): RendererOptions["align"];
-    set align(val: RendererOptions["align"]);
-    constructor({ align }?: Partial<RendererOptions>);
+    get strategy(): RenderingStrategy;
+    get align(): NonNullable<RendererOptions["align"]>;
+    set align(val: NonNullable<RendererOptions["align"]>);
+    constructor({ align, strategy }: RendererOptions);
     abstract render(): Promise<void>;
-    abstract forceRenderAllPanels(): Promise<void>;
     protected abstract _collectPanels(): void;
-    protected abstract _createPanel(el: any, options: PanelOptions): Panel;
-    protected abstract _insertPanelElements(panels: Panel[], nextSibling: Panel | null): void;
-    protected abstract _removePanelElements(panels: Panel[]): void;
+    protected abstract _createPanel(el: any, options: Omit<PanelOptions, "elementProvider">): Panel;
     init(flicking: Flicking): this;
     destroy(): void;
     getPanel(index: number): Panel | null;
+    forceRenderAllPanels(): Promise<void>;
     updatePanelSize(): this;
     batchInsert(...items: Array<{
         index: number;
         elements: any[];
+        hasDOMInElements: boolean;
     }>): Panel[];
     batchRemove(...items: Array<{
         index: number;
         deleteCount: number;
+        hasDOMInElements: boolean;
     }>): Panel[];
     checkPanelContentsReady(checkingPanels: Panel[]): void;
-    protected _getPanelAlign(): string | number;
     protected _updateCameraAndControl(): void;
-    protected _updateRenderingPanels(): void;
     protected _showOnlyVisiblePanels(flicking: Flicking): void;
-    protected _updatePanelSizeByGrid(flicking: Flicking): void;
+    protected _updatePanelSizeByGrid(referencePanel: Panel, panels: Panel[]): void;
+    protected _removeAllChildsFromCamera(): void;
+    protected _insertPanelElements(panels: Panel[], nextSibling?: Panel | null): void;
+    protected _removePanelElements(panels: Panel[]): void;
 }
 export default Renderer;

package/declaration/renderer/VanillaRenderer.d.ts

@@ -1,15 +1,10 @@
 import Panel, { PanelOptions } from "../core/panel/Panel";
-import ElementPanel from "../core/panel/ElementPanel";
 import Renderer from "./Renderer";
 declare class VanillaRenderer extends Renderer {
     render(): Promise<void>;
-    forceRenderAllPanels(): Promise<void>;
     protected _collectPanels(): void;
-    protected _createPanel(el: HTMLElement, options: PanelOptions): ElementPanel;
-    protected _insertPanelElements(panels: Panel[], nextSibling: Panel | null): this;
-    protected _removePanelElements(panels: Panel[]): this;
+    protected _createPanel(el: HTMLElement, options: Omit<PanelOptions, "elementProvider">): Panel;
     private _resetPanelElementOrder;
-    private _removeAllChildsFromCamera;
-    private _getRenderingPanelsByOrder;
+    private _removeAllTextNodes;
 }
 export default VanillaRenderer;

package/declaration/renderer/index.d.ts

@@ -1,5 +1,6 @@
 import Renderer, { RendererOptions } from "./Renderer";
 import VanillaRenderer from "./VanillaRenderer";
 import ExternalRenderer from "./ExternalRenderer";
+export * from "./strategy";
 export { Renderer, VanillaRenderer, ExternalRenderer };
 export type { RendererOptions };

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

@@ -0,0 +1,23 @@
+import Flicking from "../../Flicking";
+import Panel, { PanelOptions } from "../../core/panel/Panel";
+import ElementProvider from "../../core/panel/provider/ElementProvider";
+import RenderingStrategy from "./RenderingStrategy";
+export interface NormalRenderingStrategyOptions {
+    providerCtor: new (...args: any) => ElementProvider;
+}
+declare class NormalRenderingStrategy implements RenderingStrategy {
+    private _providerCtor;
+    constructor({ providerCtor }: NormalRenderingStrategyOptions);
+    renderPanels(): void;
+    getRenderingIndexesByOrder(flicking: Flicking): number[];
+    getRenderingElementsByOrder(flicking: Flicking): HTMLElement[];
+    updateRenderingPanels(flicking: Flicking): void;
+    collectPanels(flicking: Flicking, elements: any[]): Panel[];
+    createPanel(element: any, options: Omit<PanelOptions, "elementProvider">): Panel;
+    updatePanelSizes(flicking: Flicking, size: Partial<{
+        width: number | string;
+        height: number | string;
+    }>): void;
+    private _showOnlyVisiblePanels;
+}
+export default NormalRenderingStrategy;

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

@@ -0,0 +1,15 @@
+import Flicking from "../../Flicking";
+import Panel, { PanelOptions } from "../../core/panel/Panel";
+interface RenderingStrategy {
+    renderPanels(flicking: Flicking): void;
+    getRenderingIndexesByOrder(flicking: Flicking): number[];
+    getRenderingElementsByOrder(flicking: Flicking): HTMLElement[];
+    updateRenderingPanels(flicking: Flicking): void;
+    createPanel(element: any, options: Omit<PanelOptions, "elementProvider">): Panel;
+    collectPanels(flicking: Flicking, elements: any[]): Panel[];
+    updatePanelSizes(flicking: Flicking, size: Partial<{
+        width: number | string;
+        height: number | string;
+    }>): void;
+}
+export default RenderingStrategy;

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

@@ -0,0 +1,17 @@
+import Flicking from "../../Flicking";
+import { PanelOptions } from "../../core/panel/Panel";
+import VirtualPanel from "../../core/panel/VirtualPanel";
+import RenderingStrategy from "./RenderingStrategy";
+declare class VirtualRenderingStrategy implements RenderingStrategy {
+    renderPanels(flicking: Flicking): void;
+    getRenderingIndexesByOrder(flicking: Flicking): number[];
+    getRenderingElementsByOrder(flicking: Flicking): HTMLElement[];
+    updateRenderingPanels(flicking: Flicking): void;
+    collectPanels(flicking: Flicking): VirtualPanel[];
+    createPanel(_el: any, options: PanelOptions): VirtualPanel;
+    updatePanelSizes(flicking: Flicking, size: Partial<{
+        width: number | string;
+        height: number | string;
+    }>): void;
+}
+export default VirtualRenderingStrategy;

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

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

package/declaration/type/external.d.ts

@@ -20,9 +20,7 @@ export interface Status {
         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 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;

package/declaration/utils.d.ts

@@ -6,7 +6,7 @@ export declare const merge: <From extends object, To extends object>(target: Fro
 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, nameToThrowOnError: string) => Flicking;
+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[];
@@ -16,6 +16,7 @@ export declare const parseArithmeticExpression: (cssValue: number | string) => {
     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;
@@ -27,6 +28,11 @@ export declare const findRight: <T>(array: T[], checker: (val: T) => boolean) =>
 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 setPrototypeOf: (o: any, proto: object) => any;