@fountain-ui/lab 2.0.0-beta.4 → 2.0.0-beta.40

package/build/module/Carousel/hooks/usePagingAnimator.js

@@ -0,0 +1,192 @@
+import { useCallback, useMemo, useRef } from 'react';
+import { Animated } from 'react-native';
+import { useAnimatedValue } from '@fountain-ui/core';
+
+function directionToValue(itemWidth) {
+  return function (direction) {
+    switch (direction) {
+      case 'next':
+        return -itemWidth;
+
+      case 'prev':
+        return itemWidth;
+
+      case 'stay':
+        return 0;
+    }
+  };
+}
+
+function toValueCompensator(itemWidth) {
+  return function (toValue, currentOffset) {
+    const remainder = Math.abs(currentOffset % itemWidth);
+    const halfOfItemWidth = Math.abs(itemWidth / 2);
+    const compensateVector = remainder > halfOfItemWidth ? remainder - itemWidth : remainder;
+    const direction = currentOffset > 0 ? -1 : 1;
+    return toValue + direction * compensateVector;
+  };
+}
+
+export default function usePagingAnimator(config) {
+  const {
+    createScrollAnimation,
+    itemWidth,
+    indexController,
+    initialIndex,
+    loop,
+    numberOfData
+  } = config;
+  const {
+    getCurrentIndex,
+    lastIndex,
+    notifyScrollStateHasChanged
+  } = indexController;
+  const initialOffsetX = itemWidth * initialIndex;
+  const accumulativeOffsetX = useAnimatedValue(initialOffsetX);
+  const animationOffsetX = useAnimatedValue(0);
+  const gestureTranslationX = useAnimatedValue(0);
+  const globalInterpolation = useMemo(() => {
+    return Animated.add(Animated.add(accumulativeOffsetX, animationOffsetX), gestureTranslationX);
+  }, []);
+  const toValueRef = useRef(0);
+  const currentOffsetRef = useRef(0);
+  const isAnimatingRef = useRef(false);
+  const maxWidth = Math.abs(numberOfData * itemWidth);
+  const ensureOffsetBoundary = useCallback(offset => {
+    if (loop) {
+      const isCloseToEnd = Math.abs(offset) >= maxWidth - itemWidth;
+
+      if (isCloseToEnd) {
+        const signOfOffset = offset > 0 ? 1 : -1;
+        return offset + -signOfOffset * maxWidth;
+      }
+    }
+
+    return offset % maxWidth;
+  }, [itemWidth, loop, maxWidth]);
+  const requireNewOffset = useCallback(newOffset => {
+    const nextOffset = ensureOffsetBoundary(newOffset);
+    currentOffsetRef.current = nextOffset;
+    accumulativeOffsetX.setValue(nextOffset);
+    toValueRef.current = 0;
+    animationOffsetX.setValue(0);
+  }, [ensureOffsetBoundary]);
+  const interruptAnimation = useCallback(() => {
+    if (!isAnimatingRef.current) {
+      return;
+    }
+
+    animationOffsetX.stopAnimation(lastValue => {
+      isAnimatingRef.current = false;
+      const prevOffset = currentOffsetRef.current;
+      const totalOffset = prevOffset + lastValue;
+      requireNewOffset(totalOffset);
+      notifyScrollStateHasChanged({
+        offset: totalOffset,
+        state: 'interrupted'
+      });
+    });
+  }, [notifyScrollStateHasChanged, requireNewOffset]);
+  const finalizeAnimation = useCallback(() => {
+    isAnimatingRef.current = false;
+    const prevOffset = currentOffsetRef.current;
+    const toValue = toValueRef.current;
+    const totalOffset = prevOffset + toValue;
+    requireNewOffset(totalOffset);
+    notifyScrollStateHasChanged({
+      offset: totalOffset,
+      state: 'idle'
+    });
+  }, [notifyScrollStateHasChanged, requireNewOffset]);
+  const startPagingAnimation = useCallback((type, config) => {
+    if (isAnimatingRef.current) {
+      return;
+    }
+
+    const configWithDefaults = {
+      animated: true,
+      ...config
+    };
+    const currentIndex = getCurrentIndex();
+    const getValueByDirectionOnAllAdjacentItemsVisible = directionToValue(itemWidth);
+    const compensateToValue = toValueCompensator(itemWidth);
+
+    const getValueByDirectionalPagingOnLoopDisabled = _config => {
+      const {
+        direction,
+        isOriginatedFromGesture
+      } = _config;
+
+      if (currentIndex === 0 && direction === 'prev') {
+        return isOriginatedFromGesture ? getValueByDirectionOnAllAdjacentItemsVisible('stay') : -lastIndex * itemWidth; // last position
+      } else if (currentIndex === lastIndex && direction === 'next') {
+        return isOriginatedFromGesture ? getValueByDirectionOnAllAdjacentItemsVisible('stay') : lastIndex * itemWidth; // first position
+      }
+
+      return getValueByDirectionOnAllAdjacentItemsVisible(direction);
+    };
+
+    const getValueByDirectionalPaging = _config => {
+      const _configWithDefaults = {
+        isOriginatedFromGesture: false,
+        ..._config
+      };
+      return loop ? getValueByDirectionOnAllAdjacentItemsVisible(_configWithDefaults.direction) : getValueByDirectionalPagingOnLoopDisabled(_configWithDefaults);
+    };
+
+    const getValueByIndexPaging = _ref => {
+      let {
+        index
+      } = _ref;
+
+      if (index < 0 || index > lastIndex || index === currentIndex) {
+        // no animation if index is invalid or equals to current index
+        return 0;
+      }
+
+      const distance = Math.abs(currentIndex - index) * itemWidth;
+      const direction = index > currentIndex ? -1 : 1;
+      return distance * direction;
+    };
+
+    const wantedToValue = type === 'directional' // @ts-ignore
+    ? getValueByDirectionalPaging(configWithDefaults) // @ts-ignore
+    : getValueByIndexPaging(configWithDefaults);
+    const toValue = compensateToValue(wantedToValue, currentOffsetRef.current);
+    toValueRef.current = toValue;
+    isAnimatingRef.current = true;
+    notifyScrollStateHasChanged({
+      offset: currentOffsetRef.current + toValue,
+      state: 'dragging'
+    });
+    const lastGestureTranslationX = configWithDefaults.lastGestureTranslationX ?? 0;
+
+    if (Number.isFinite(lastGestureTranslationX)) {
+      animationOffsetX.setValue(lastGestureTranslationX);
+      gestureTranslationX.setValue(0);
+    }
+
+    if (configWithDefaults.animated) {
+      const animation = createScrollAnimation(animationOffsetX, toValue);
+      animation.start(_ref2 => {
+        let {
+          finished
+        } = _ref2;
+
+        if (finished) {
+          finalizeAnimation();
+        }
+      });
+    } else {
+      finalizeAnimation();
+    }
+  }, [createScrollAnimation, getCurrentIndex, finalizeAnimation, itemWidth, lastIndex, loop, notifyScrollStateHasChanged]);
+  return {
+    gestureTranslationX,
+    globalInterpolation,
+    interruptAnimation,
+    startPagingAnimation
+  };
+}
+;
+//# sourceMappingURL=usePagingAnimator.js.map

package/build/module/Carousel/hooks/usePagingAnimator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useMemo","useRef","Animated","useAnimatedValue","directionToValue","itemWidth","direction","toValueCompensator","toValue","currentOffset","remainder","Math","abs","halfOfItemWidth","compensateVector","usePagingAnimator","config","createScrollAnimation","indexController","initialIndex","loop","numberOfData","getCurrentIndex","lastIndex","notifyScrollStateHasChanged","initialOffsetX","accumulativeOffsetX","animationOffsetX","gestureTranslationX","globalInterpolation","add","toValueRef","currentOffsetRef","isAnimatingRef","maxWidth","ensureOffsetBoundary","offset","isCloseToEnd","signOfOffset","requireNewOffset","newOffset","nextOffset","current","setValue","interruptAnimation","stopAnimation","lastValue","prevOffset","totalOffset","state","finalizeAnimation","startPagingAnimation","type","configWithDefaults","animated","currentIndex","getValueByDirectionOnAllAdjacentItemsVisible","compensateToValue","getValueByDirectionalPagingOnLoopDisabled","_config","isOriginatedFromGesture","getValueByDirectionalPaging","_configWithDefaults","getValueByIndexPaging","index","distance","wantedToValue","lastGestureTranslationX","Number","isFinite","animation","start","finished"],"sources":["usePagingAnimator.ts"],"sourcesContent":["import { useCallback, useMemo, useRef } from 'react';\nimport { Animated } from 'react-native';\nimport { useAnimatedValue } from '@fountain-ui/core';\nimport type {\n    CreateScrollAnimation,\n    DirectionalPagingAnimationConfig,\n    IndexController,\n    IndexPagingAnimationConfig,\n    PagingAnimationConfig,\n    PagingAnimationType,\n    PagingDirection,\n    StartPagingAnimation,\n} from '../types';\n\nexport interface PagingAnimatorConfig {\n    createScrollAnimation: CreateScrollAnimation;\n    itemWidth: number;\n    indexController: IndexController;\n    initialIndex: number;\n    loop: boolean;\n    numberOfData: number;\n}\n\nexport interface PagingAnimator {\n    gestureTranslationX: Animated.Value;\n    globalInterpolation: Animated.AnimatedInterpolation;\n    interruptAnimation: () => void;\n    startPagingAnimation: StartPagingAnimation;\n}\n\nfunction directionToValue(itemWidth: number) {\n    return function (direction: PagingDirection): number {\n        switch (direction) {\n            case 'next':\n                return -itemWidth;\n            case 'prev':\n                return itemWidth;\n            case 'stay':\n                return 0;\n        }\n    };\n}\n\nfunction toValueCompensator(itemWidth: number) {\n    return function (toValue: number, currentOffset: number): number {\n        const remainder = Math.abs(currentOffset % itemWidth);\n\n        const halfOfItemWidth = Math.abs(itemWidth / 2);\n        const compensateVector = remainder > halfOfItemWidth\n            ? remainder - itemWidth\n            : remainder;\n\n        const direction = currentOffset > 0 ? -1 : 1;\n\n        return toValue + (direction * compensateVector);\n    };\n}\n\nexport default function usePagingAnimator(config: PagingAnimatorConfig): PagingAnimator {\n    const {\n        createScrollAnimation,\n        itemWidth,\n        indexController,\n        initialIndex,\n        loop,\n        numberOfData,\n    } = config;\n\n    const {\n        getCurrentIndex,\n        lastIndex,\n        notifyScrollStateHasChanged,\n    } = indexController;\n\n    const initialOffsetX = itemWidth * initialIndex;\n    const accumulativeOffsetX = useAnimatedValue(initialOffsetX);\n    const animationOffsetX = useAnimatedValue(0);\n    const gestureTranslationX = useAnimatedValue(0);\n\n    const globalInterpolation = useMemo(() => {\n        return Animated.add(\n            Animated.add(accumulativeOffsetX, animationOffsetX),\n            gestureTranslationX,\n        );\n    }, []);\n\n    const toValueRef = useRef<number>(0);\n    const currentOffsetRef = useRef<number>(0);\n\n    const isAnimatingRef = useRef<boolean>(false);\n\n    const maxWidth = Math.abs(numberOfData * itemWidth);\n\n    const ensureOffsetBoundary: (offset: number) => number = useCallback((offset: number) => {\n        if (loop) {\n            const isCloseToEnd = Math.abs(offset) >= (maxWidth - itemWidth);\n            if (isCloseToEnd) {\n                const signOfOffset = offset > 0 ? 1 : -1;\n                return offset + (-signOfOffset * maxWidth);\n            }\n        }\n\n        return offset % maxWidth;\n    }, [itemWidth, loop, maxWidth]);\n\n    const requireNewOffset = useCallback((newOffset: number) => {\n        const nextOffset = ensureOffsetBoundary(newOffset);\n\n        currentOffsetRef.current = nextOffset;\n        accumulativeOffsetX.setValue(nextOffset);\n\n        toValueRef.current = 0;\n        animationOffsetX.setValue(0);\n    }, [\n        ensureOffsetBoundary,\n    ]);\n\n    const interruptAnimation = useCallback(() => {\n        if (!isAnimatingRef.current) {\n            return;\n        }\n\n        animationOffsetX.stopAnimation(lastValue => {\n            isAnimatingRef.current = false;\n\n            const prevOffset = currentOffsetRef.current;\n            const totalOffset = prevOffset + lastValue;\n\n            requireNewOffset(totalOffset);\n\n            notifyScrollStateHasChanged({ offset: totalOffset, state: 'interrupted' });\n        });\n    }, [\n        notifyScrollStateHasChanged,\n        requireNewOffset,\n    ]);\n\n    const finalizeAnimation = useCallback(() => {\n        isAnimatingRef.current = false;\n\n        const prevOffset = currentOffsetRef.current;\n        const toValue = toValueRef.current;\n        const totalOffset = prevOffset + toValue;\n\n        requireNewOffset(totalOffset);\n\n        notifyScrollStateHasChanged({ offset: totalOffset, state: 'idle' });\n    }, [\n        notifyScrollStateHasChanged,\n        requireNewOffset,\n    ]);\n\n    const startPagingAnimation = useCallback((type: PagingAnimationType, config: PagingAnimationConfig) => {\n        if (isAnimatingRef.current) {\n            return;\n        }\n\n        const configWithDefaults: PagingAnimationConfig = {\n            animated: true,\n            ...config,\n        };\n\n        const currentIndex = getCurrentIndex();\n\n        const getValueByDirectionOnAllAdjacentItemsVisible = directionToValue(itemWidth);\n        const compensateToValue = toValueCompensator(itemWidth);\n\n        const getValueByDirectionalPagingOnLoopDisabled = (_config: DirectionalPagingAnimationConfig): number => {\n            const { direction, isOriginatedFromGesture } = _config;\n\n            if (currentIndex === 0 && direction === 'prev') {\n                return isOriginatedFromGesture\n                    ? getValueByDirectionOnAllAdjacentItemsVisible('stay')\n                    : -lastIndex * itemWidth; // last position\n            } else if (currentIndex === lastIndex && direction === 'next') {\n                return isOriginatedFromGesture\n                    ? getValueByDirectionOnAllAdjacentItemsVisible('stay')\n                    : lastIndex * itemWidth; // first position\n            }\n            return getValueByDirectionOnAllAdjacentItemsVisible(direction);\n        };\n\n        const getValueByDirectionalPaging = (_config: DirectionalPagingAnimationConfig): number => {\n            const _configWithDefaults: DirectionalPagingAnimationConfig = {\n                isOriginatedFromGesture: false,\n                ..._config,\n            };\n\n            return loop\n                ? getValueByDirectionOnAllAdjacentItemsVisible(_configWithDefaults.direction)\n                : getValueByDirectionalPagingOnLoopDisabled(_configWithDefaults);\n        };\n\n        const getValueByIndexPaging = ({ index }: IndexPagingAnimationConfig): number => {\n            if (index < 0 || index > lastIndex || index === currentIndex) {\n                // no animation if index is invalid or equals to current index\n                return 0;\n            }\n\n            const distance = Math.abs(currentIndex - index) * itemWidth;\n            const direction = index > currentIndex ? -1 : 1;\n\n            return distance * direction;\n        };\n\n        const wantedToValue = type === 'directional'\n            // @ts-ignore\n            ? getValueByDirectionalPaging(configWithDefaults)\n            // @ts-ignore\n            : getValueByIndexPaging(configWithDefaults);\n\n        const toValue = compensateToValue(wantedToValue, currentOffsetRef.current);\n\n        toValueRef.current = toValue;\n        isAnimatingRef.current = true;\n\n        notifyScrollStateHasChanged({\n            offset: currentOffsetRef.current + toValue,\n            state: 'dragging',\n        });\n\n        const lastGestureTranslationX: number = configWithDefaults.lastGestureTranslationX ?? 0;\n        if (Number.isFinite(lastGestureTranslationX)) {\n            animationOffsetX.setValue(lastGestureTranslationX);\n            gestureTranslationX.setValue(0);\n        }\n\n        if (configWithDefaults.animated) {\n            const animation = createScrollAnimation(animationOffsetX, toValue);\n\n            animation.start(({ finished }) => {\n                if (finished) {\n                    finalizeAnimation();\n                }\n            });\n        } else {\n            finalizeAnimation();\n        }\n    }, [\n        createScrollAnimation,\n        getCurrentIndex,\n        finalizeAnimation,\n        itemWidth,\n        lastIndex,\n        loop,\n        notifyScrollStateHasChanged,\n    ]);\n\n    return {\n        gestureTranslationX,\n        globalInterpolation,\n        interruptAnimation,\n        startPagingAnimation,\n    };\n};\n"],"mappings":"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"}

package/build/module/Carousel/index.js

@@ -1,2 +1,3 @@
-export { default } from './CarouselWeb';
+export { default } from './Carousel';
+export { normalItemStyleFactory, parallaxItemStyleFactory } from './animation';
 //# sourceMappingURL=index.js.map

package/build/module/Carousel/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"names":["default"],"mappings":"AAAA,SAASA,OAAT,QAAwB,eAAxB","sourcesContent":["export { default } from './CarouselWeb';\nexport type { default as CarouselProps } from './CarouselProps';"]}
+{"version":3,"names":["default","normalItemStyleFactory","parallaxItemStyleFactory"],"sources":["index.ts"],"sourcesContent":["export { default } from './Carousel';\nexport type { default as CarouselProps } from './CarouselProps';\nexport type { CarouselInstance } from './types';\nexport { normalItemStyleFactory, parallaxItemStyleFactory } from './animation';\n"],"mappings":"AAAA,SAASA,OAAT,QAAwB,YAAxB;AAGA,SAASC,sBAAT,EAAiCC,wBAAjC,QAAiE,aAAjE"}

package/build/module/Carousel/tick.js

@@ -0,0 +1,6 @@
+import { logger } from '@fountain-ui/utils';
+export default logger('Carousel', {
+  enabled: __DEV__,
+  format: 'diff'
+});
+//# sourceMappingURL=tick.js.map

package/build/module/Carousel/tick.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["logger","enabled","__DEV__","format"],"sources":["tick.ts"],"sourcesContent":["import { logger } from '@fountain-ui/utils';\n\nexport default logger('Carousel', {\n    enabled: __DEV__,\n    format: 'diff',\n});\n"],"mappings":"AAAA,SAASA,MAAT,QAAuB,oBAAvB;AAEA,eAAeA,MAAM,CAAC,UAAD,EAAa;EAC9BC,OAAO,EAAEC,OADqB;EAE9BC,MAAM,EAAE;AAFsB,CAAb,CAArB"}

package/build/module/Carousel/types.js

@@ -0,0 +1,4 @@
+const directions = ['next', 'prev', 'stay'];
+const scrollStates = ['idle', 'dragging', 'interrupted'];
+export {};
+//# sourceMappingURL=types.js.map

package/build/module/Carousel/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["directions","scrollStates"],"sources":["types.ts"],"sourcesContent":["import type { ReactElement } from 'react';\nimport type { Animated, ViewProps } from 'react-native';\n\nconst directions = ['next', 'prev', 'stay'] as const;\n\nexport type PagingDirection = (typeof directions)[number];\n\nconst scrollStates = ['idle', 'dragging', 'interrupted'] as const;\n\nexport type ScrollState = (typeof scrollStates)[number];\n\nexport type ItemHeight = number | 'auto';\n\nexport interface RenderItem<T> {\n    (info: { item: T, index: number, interpolation: Animated.AnimatedInterpolation }): ReactElement | null;\n}\n\nexport interface CreateScrollAnimation {\n    (aValue: Animated.AnimatedValue, toValue: number): Animated.CompositeAnimation;\n}\n\nexport interface CreateItemStyle {\n    (itemInterpolation: Animated.AnimatedInterpolation, itemWidth: number): Animated.AnimatedProps<ViewProps['style']>;\n}\n\nexport interface GetCurrentIndex {\n    (): number;\n}\n\nexport interface OnIndexChange {\n    (itemIndex: number): void;\n}\n\nexport interface OnPositionChange {\n    (position: number): void;\n}\n\nexport interface ScrollStateChangeEvent {\n    offset: number;\n    state: ScrollState;\n}\n\nexport interface IndexController {\n    getCurrentIndex: GetCurrentIndex;\n    lastIndex: number;\n    notifyScrollStateHasChanged: (event: ScrollStateChangeEvent) => void;\n}\n\nexport type PagingAnimationType = 'directional' | 'index';\n\nexport interface BasePagingAnimationConfig {\n    animated?: boolean;\n    lastGestureTranslationX?: number;\n}\n\nexport interface DirectionalPagingAnimationConfig extends BasePagingAnimationConfig {\n    direction: PagingDirection;\n    isOriginatedFromGesture?: boolean;\n}\n\nexport interface IndexPagingAnimationConfig extends BasePagingAnimationConfig {\n    index: number;\n}\n\nexport type PagingAnimationConfig = DirectionalPagingAnimationConfig | IndexPagingAnimationConfig;\n\nexport interface StartPagingAnimation {\n    (type: PagingAnimationType, config: PagingAnimationConfig): void;\n}\n\nexport type VisibleIndexRanges = Array<[number, number]>;\n\nexport interface StoreSubscription {\n    (): void;\n}\n\nexport interface ItemVisibilityStore {\n    dispatch: (ranges: VisibleIndexRanges) => void;\n    subscribe: (listener: (ranges: VisibleIndexRanges) => void) => StoreSubscription;\n    removeAllListeners: () => void;\n}\n\nexport interface AutoplayController {\n    pause: () => void;\n    resume: () => void;\n}\n\nexport interface ScrollToOption {\n    index: number;\n    animated?: boolean;\n}\n\nexport interface CarouselInstance {\n    /**\n     * Get current visible item index.\n     */\n    getCurrentIndex: GetCurrentIndex;\n\n    /**\n     * Scroll to next visible item.\n     */\n    next: () => void;\n\n    /**\n     * Scroll to previous visible item.\n     */\n    prev: () => void;\n\n    /**\n     * Scroll to desired indexed item.\n     * Invalid index is ignored.\n     */\n    scrollTo: (option: ScrollToOption) => void;\n}\n"],"mappings":"AAGA,MAAMA,UAAU,GAAG,CAAC,MAAD,EAAS,MAAT,EAAiB,MAAjB,CAAnB;AAIA,MAAMC,YAAY,GAAG,CAAC,MAAD,EAAS,UAAT,EAAqB,aAArB,CAArB"}

package/build/module/ComicViewer/ComicViewer.js

@@ -1,126 +1,240 @@
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
 import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { FlatList } from 'react-native';
 import * as R from 'ramda';
+import { useDebounce } from '@fountain-ui/core';
 import ViewerItem from './ViewerItem';
 
-const getItemHeights = items => R.map(content => content.height)(items);
-
 const appender = (left, right) => [left + right, left + right];
 
-const getHeightAccum = itemHeights => R.mapAccum(appender, 0, itemHeights);
+const getHeightAccum = heights => R.mapAccum(appender, 0, heights);
+
+const keyExtractor = item => String(item.index);
+
+const createInitialImageState = dimension => ({
+  isNewUrlIncoming: false,
+  totalErrorCount: 0,
+  dimension
+});
+
+const mapImageStateToItemState = (index, imageState, autoHandleErrorCount) => {
+  var _imageState$urlState, _imageState$urlState2;
 
-const keyExtractor = item => item.id;
+  return {
+    index,
+    url: (_imageState$urlState = imageState.urlState) === null || _imageState$urlState === void 0 ? void 0 : _imageState$urlState.url,
+    reloadButtonVisible: ((_imageState$urlState2 = imageState.urlState) === null || _imageState$urlState2 === void 0 ? void 0 : _imageState$urlState2.validity) !== 'valid' && imageState.totalErrorCount >= autoHandleErrorCount,
+    dimension: imageState.dimension
+  };
+};
 
+const MAXIMUM_WIDTH = 720;
+const NUMBER_OF_ADJACENT_ITEM = 5;
 export default function ComicViewer(props) {
   const {
-    data,
-    errorDebounceMillis = 500,
-    errorRetryCount = 3,
+    debounceMillis = 100,
+    autoHandleErrorCount = 3,
+    getUrlByIndex,
     initialNumToRender = 1,
     initialScrollPercentage = 0,
     itemVisiblePercentThreshold = 0,
-    onError,
-    viewerWidth,
+    intrinsicDimensions,
+    maxContentWidth = MAXIMUM_WIDTH,
+    onItemPress,
+    viewportWidth,
     windowSize = 3,
     ...otherProps
   } = props;
   const flatListRef = useRef(null);
-  const errors = useRef(new Map());
-  const debounceTimeOut = useRef(null);
-  const resourceString = R.toString(R.map(itemData => itemData.sourceUrl)(data));
-  const initialItems = R.map(itemData => ({ ...itemData,
-    isViewable: false,
-    width: viewerWidth,
-    height: itemData.height * viewerWidth / itemData.width
-  }))(data);
-  const [items, setItems] = useState(initialItems);
-  const itemHeights = getItemHeights(items);
-  const itemHeightAccum = getHeightAccum(itemHeights);
+  const maybeLoadableItemsIndexRange = useRef([-1, 0]);
+  const actualImageWidth = Math.min(viewportWidth, maxContentWidth);
+  const initialImageStates = useMemo(() => R.map(createInitialImageState, intrinsicDimensions), []);
+  const imageStatesRef = useRef(initialImageStates);
+
+  const mapImageStatesToItemStates = imageStates => {
+    return imageStates.map((image, index) => mapImageStateToItemState(index, image, autoHandleErrorCount));
+  };
+
+  const [itemStates, setItemStates] = useState(() => {
+    return mapImageStatesToItemStates(imageStatesRef.current);
+  });
+  const renderedDimensions = useMemo(() => {
+    return R.map(intrinsicDimension => ({
+      width: actualImageWidth,
+      height: intrinsicDimension.height * actualImageWidth / intrinsicDimension.width
+    }), intrinsicDimensions);
+  }, [actualImageWidth]);
+  const layoutFromDimensions = useCallback(() => {
+    const itemHeights = R.map(dimension => dimension.height, renderedDimensions);
+    const [totalHeight, heightAccum] = getHeightAccum(itemHeights);
+    const itemOffsets = R.prepend(0, heightAccum);
+
+    const getItemLayout = (data, index) => ({
+      index,
+      length: itemHeights[index],
+      offset: itemOffsets[index]
+    });
+
+    return {
+      totalHeight,
+      getItemLayout
+    };
+  }, [renderedDimensions]);
+  const {
+    totalHeight,
+    getItemLayout
+  } = layoutFromDimensions();
   const viewabilityConfig = useMemo(() => ({
     itemVisiblePercentThreshold
   }), [itemVisiblePercentThreshold]);
-  const getItemLayout = useCallback((data, index) => {
-    const offsets = R.prepend(0, itemHeightAccum[1]);
-    return {
-      length: itemHeights[index],
-      offset: offsets[index],
-      index
-    };
-  }, [itemHeights]);
-  const onViewableItemsChanged = useRef(({
-    viewableItems
-  }) => {
-    setItems(prev => {
-      const viewableItemIds = R.map(viewableItem => viewableItem.item.id)(viewableItems);
-      return R.map(prevItem => ({ ...prevItem,
-        isViewable: R.includes(prevItem.id, viewableItemIds)
-      }))([...prev]);
+
+  const updateImageState = updateFunction => {
+    const prevImageStates = imageStatesRef.current;
+    const newImageStates = prevImageStates.map(updateFunction);
+    imageStatesRef.current = newImageStates;
+    setItemStates(prevItemStates => {
+      const newItemStates = mapImageStatesToItemStates(newImageStates);
+      return R.equals(prevItemStates, newItemStates) ? prevItemStates : newItemStates;
     });
-  });
+  };
 
-  const onErrorHandler = errors => {
-    const isRetryLimited = R.any(error => error.count >= errorRetryCount)(errors);
+  const loadUrlByIndex = async indexes => {
+    const filteredIndexes = R.filter(index => {
+      var _state$urlState;
 
-    if (isRetryLimited) {
-      return;
+      const state = imageStatesRef.current[index];
+      return R.isNil(state.urlState) || ((_state$urlState = state.urlState) === null || _state$urlState === void 0 ? void 0 : _state$urlState.validity) === 'invalid' && !state.isNewUrlIncoming;
+    }, indexes);
+    updateImageState((imageState, i) => {
+      return R.includes(i, filteredIndexes) ? { ...imageState,
+        isNewUrlIncoming: true
+      } : imageState;
+    });
+
+    try {
+      const urls = await getUrlByIndex(filteredIndexes);
+      updateImageState((imageState, i) => {
+        const newUrl = urls === null || urls === void 0 ? void 0 : urls.get(i);
+        const urlState = imageState.urlState;
+
+        if (newUrl !== undefined && (urlState === null || urlState === void 0 ? void 0 : urlState.validity) !== 'valid') {
+          return { ...imageState,
+            urlState: {
+              url: newUrl,
+              validity: 'unknown'
+            }
+          };
+        }
+
+        return imageState;
+      });
+    } finally {
+      updateImageState((imageState, i) => {
+        return R.includes(i, filteredIndexes) ? { ...imageState,
+          isNewUrlIncoming: false
+        } : imageState;
+      });
     }
+  };
 
-    onError && onError(errors);
+  const loadMaybeLoadableItems = async () => {
+    const [startIndex, endIndex] = maybeLoadableItemsIndexRange.current;
+    const affectedIndexes = R.range(startIndex, endIndex);
+    await loadUrlByIndex(affectedIndexes);
   };
 
-  const itemErrorHandler = useCallback(errorInfo => {
-    errors.current.set(errorInfo.id, errorInfo.count);
+  const loadItemsDebounce = useDebounce(loadMaybeLoadableItems, debounceMillis);
+  const onViewableItemsChanged = useRef(_ref => {
+    var _R$head, _R$last;
 
-    if (debounceTimeOut.current) {
-      clearTimeout(debounceTimeOut.current);
+    let {
+      viewableItems
+    } = _ref;
+    const orderedViewableItems = R.sort((a, b) => (a.index || 0) - (b.index || 0), viewableItems);
+    const firstViewableIndex = (_R$head = R.head(orderedViewableItems)) === null || _R$head === void 0 ? void 0 : _R$head.index;
+    const lastViewableItemIndex = (_R$last = R.last(orderedViewableItems)) === null || _R$last === void 0 ? void 0 : _R$last.index;
+
+    if (R.isNil(firstViewableIndex) || R.isNil(lastViewableItemIndex)) {
+      return;
     }
 
-    debounceTimeOut.current = setTimeout(function () {
-      const errorsArray = Array.from(errors.current.entries());
-      const errorsInfo = R.map(([key, value]) => ({
-        id: key,
-        count: value
-      }))(errorsArray);
-      onErrorHandler([...errorsInfo]);
-      errors.current.clear();
-    }, errorDebounceMillis);
-  }, [errorDebounceMillis, errors.current]);
-  const renderItem = useCallback(({
-    item
-  }) => {
-    const props = { ...item,
-      onError: itemErrorHandler
+    const startIndex = R.max(firstViewableIndex - NUMBER_OF_ADJACENT_ITEM, 0);
+    const endIndex = R.min(lastViewableItemIndex + NUMBER_OF_ADJACENT_ITEM, itemStates.length - 1);
+    maybeLoadableItemsIndexRange.current = [startIndex, endIndex + 1];
+    loadItemsDebounce();
+  });
+  const renderItem = useCallback(_ref2 => {
+    var _renderedDimensions$i, _renderedDimensions$i2;
+
+    let {
+      item,
+      index
+    } = _ref2;
+
+    const onError = () => {
+      updateImageState((imageState, i) => {
+        const urlState = imageState.urlState;
+
+        if (i === index && urlState !== undefined) {
+          return { ...imageState,
+            totalErrorCount: imageState.totalErrorCount + 1,
+            urlState: { ...urlState,
+              validity: 'invalid'
+            }
+          };
+        }
+
+        return imageState;
+      });
+
+      if (item.reloadButtonVisible) {
+        return;
+      }
+
+      const [startIndex, endIndex] = maybeLoadableItemsIndexRange.current;
+
+      if (index >= startIndex || index < endIndex) {
+        loadItemsDebounce();
+      }
+    };
+
+    const onReloadPress = () => {
+      const [startIndex, endIndex] = maybeLoadableItemsIndexRange.current;
+
+      if (index >= startIndex || index < endIndex) {
+        loadUrlByIndex([index]);
+      }
     };
-    return /*#__PURE__*/React.createElement(ViewerItem, {
-      props: props
-    });
-  }, []);
-  useEffect(() => {
-    setItems(prev => {
-      return R.map(prevItem => {
-        const currentData = R.find(currentItemData => prevItem.id === currentItemData.id)(data);
 
-        if (currentData && currentData.sourceUrl !== prevItem.sourceUrl) {
-          return { ...prevItem,
-            sourceUrl: currentData.sourceUrl
+    const onLoad = () => {
+      updateImageState((imageState, i) => {
+        const urlState = imageState.urlState;
+
+        if (i === index && urlState !== undefined) {
+          return { ...imageState,
+            urlState: { ...urlState,
+              validity: 'valid'
+            }
           };
         }
 
-        return prevItem;
-      })([...prev]);
+        return imageState;
+      });
+    };
+
+    return /*#__PURE__*/React.createElement(ViewerItem, {
+      onError: onError,
+      onLoad: onLoad,
+      onPress: onItemPress,
+      onReloadPress: onReloadPress,
+      url: item.url,
+      width: ((_renderedDimensions$i = renderedDimensions[index]) === null || _renderedDimensions$i === void 0 ? void 0 : _renderedDimensions$i.width) ?? 0,
+      height: ((_renderedDimensions$i2 = renderedDimensions[index]) === null || _renderedDimensions$i2 === void 0 ? void 0 : _renderedDimensions$i2.height) ?? 0,
+      reloadButtonVisible: item.reloadButtonVisible
     });
-  }, [resourceString]);
-  useEffect(() => {
-    const newItems = R.map(item => ({ ...item,
-      width: viewerWidth,
-      height: item.height * viewerWidth / item.width
-    }))(items);
-    setItems(newItems);
-  }, [viewerWidth]);
+  }, [onItemPress, renderedDimensions]);
   useEffect(() => {
-    const totalHeight = itemHeightAccum[0];
     const offset = Math.floor(initialScrollPercentage / 100 * totalHeight);
 
     if (flatListRef.current) {
@@ -129,14 +243,15 @@ export default function ComicViewer(props) {
         animated: false
       });
     }
-  }, [flatListRef.current]);
+  }, []);
   return /*#__PURE__*/React.createElement(FlatList, _extends({
-    data: items,
+    data: itemStates,
     getItemLayout: getItemLayout,
     initialNumToRender: initialNumToRender,
     keyExtractor: keyExtractor,
     onViewableItemsChanged: onViewableItemsChanged.current,
     ref: flatListRef,
+    removeClippedSubviews: false,
     renderItem: renderItem,
     viewabilityConfig: viewabilityConfig,
     windowSize: windowSize