@pixui-dev/pxw 0.1.19 → 0.1.21

package/lib/react-window/src/FixedSizeGrid.js

@@ -1,172 +1,172 @@
-// @flow
-
-import createGridComponent from './createGridComponent';
-
-import type { Props, ScrollToAlign } from './createGridComponent';
-
-const FixedSizeGrid = createGridComponent({
-	getColumnOffset: ({ columnWidth }: Props<any>, index: number): number => index * ((columnWidth: any): number),
-
-	getColumnWidth: ({ columnWidth }: Props<any>, index: number): number => ((columnWidth: any): number),
-
-	getRowOffset: ({ rowHeight }: Props<any>, index: number): number => index * ((rowHeight: any): number),
-
-	getRowHeight: ({ rowHeight }: Props<any>, index: number): number => ((rowHeight: any): number),
-
-	getEstimatedTotalHeight: ({ rowCount, rowHeight }: Props<any>) => ((rowHeight: any): number) * rowCount,
-
-	getEstimatedTotalWidth: ({ columnCount, columnWidth }: Props<any>) => ((columnWidth: any): number) * columnCount,
-
-	getOffsetForColumnAndAlignment: (
-		{ columnCount, columnWidth, width }: Props<any>,
-		columnIndex: number,
-		align: ScrollToAlign,
-		scrollLeft: number,
-		instanceProps: typeof undefined,
-		scrollbarSize: number,
-	): number => {
-		const lastColumnOffset = Math.max(0, columnCount * ((columnWidth: any): number) - width);
-		const maxOffset = Math.min(lastColumnOffset, columnIndex * ((columnWidth: any): number));
-		const minOffset = Math.max(0, columnIndex * ((columnWidth: any): number) - width + scrollbarSize + ((columnWidth: any): number));
-
-		if (align === 'smart') {
-			if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
-				align = 'auto';
-			} else {
-				align = 'center';
-			}
-		}
-
-		switch (align) {
-			case 'start':
-				return maxOffset;
-			case 'end':
-				return minOffset;
-			case 'center':
-				// "Centered" offset is usually the average of the min and max.
-				// But near the edges of the list, this doesn't hold true.
-				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
-				if (middleOffset < Math.ceil(width / 2)) {
-					return 0; // near the beginning
-				} else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
-					return lastColumnOffset; // near the end
-				} else {
-					return middleOffset;
-				}
-			case 'auto':
-			default:
-				if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
-					return scrollLeft;
-				} else if (minOffset > maxOffset) {
-					// Because we only take into account the scrollbar size when calculating minOffset
-					// this value can be larger than maxOffset when at the end of the list
-					return minOffset;
-				} else if (scrollLeft < minOffset) {
-					return minOffset;
-				} else {
-					return maxOffset;
-				}
-		}
-	},
-
-	getOffsetForRowAndAlignment: (
-		{ rowHeight, height, rowCount }: Props<any>,
-		rowIndex: number,
-		align: ScrollToAlign,
-		scrollTop: number,
-		instanceProps: typeof undefined,
-		scrollbarSize: number,
-	): number => {
-		const lastRowOffset = Math.max(0, rowCount * ((rowHeight: any): number) - height);
-		const maxOffset = Math.min(lastRowOffset, rowIndex * ((rowHeight: any): number));
-		const minOffset = Math.max(0, rowIndex * ((rowHeight: any): number) - height + scrollbarSize + ((rowHeight: any): number));
-
-		if (align === 'smart') {
-			if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
-				align = 'auto';
-			} else {
-				align = 'center';
-			}
-		}
-
-		switch (align) {
-			case 'start':
-				return maxOffset;
-			case 'end':
-				return minOffset;
-			case 'center':
-				// "Centered" offset is usually the average of the min and max.
-				// But near the edges of the list, this doesn't hold true.
-				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
-				if (middleOffset < Math.ceil(height / 2)) {
-					return 0; // near the beginning
-				} else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
-					return lastRowOffset; // near the end
-				} else {
-					return middleOffset;
-				}
-			case 'auto':
-			default:
-				if (scrollTop >= minOffset && scrollTop <= maxOffset) {
-					return scrollTop;
-				} else if (minOffset > maxOffset) {
-					// Because we only take into account the scrollbar size when calculating minOffset
-					// this value can be larger than maxOffset when at the end of the list
-					return minOffset;
-				} else if (scrollTop < minOffset) {
-					return minOffset;
-				} else {
-					return maxOffset;
-				}
-		}
-	},
-
-	getColumnStartIndexForOffset: ({ columnWidth, columnCount }: Props<any>, scrollLeft: number): number =>
-		Math.max(0, Math.min(columnCount - 1, Math.floor(scrollLeft / ((columnWidth: any): number)))),
-
-	getColumnStopIndexForStartIndex: ({ columnWidth, columnCount, width }: Props<any>, startIndex: number, scrollLeft: number): number => {
-		const left = startIndex * ((columnWidth: any): number);
-		const numVisibleColumns = Math.ceil((width + scrollLeft - left) / ((columnWidth: any): number));
-		return Math.max(
-			0,
-			Math.min(
-				columnCount - 1,
-				startIndex + numVisibleColumns - 1, // -1 is because stop index is inclusive
-			),
-		);
-	},
-
-	getRowStartIndexForOffset: ({ rowHeight, rowCount }: Props<any>, scrollTop: number): number => Math.max(0, Math.min(rowCount - 1, Math.floor(scrollTop / ((rowHeight: any): number)))),
-
-	getRowStopIndexForStartIndex: ({ rowHeight, rowCount, height }: Props<any>, startIndex: number, scrollTop: number): number => {
-		const top = startIndex * ((rowHeight: any): number);
-		const numVisibleRows = Math.ceil((height + scrollTop - top) / ((rowHeight: any): number));
-		return Math.max(
-			0,
-			Math.min(
-				rowCount - 1,
-				startIndex + numVisibleRows - 1, // -1 is because stop index is inclusive
-			),
-		);
-	},
-
-	initInstanceProps(props: Props<any>): any {
-		// Noop
-	},
-
-	shouldResetStyleCacheOnItemSizeChange: true,
-
-	validateProps: ({ columnWidth, rowHeight }: Props<any>): void => {
-		if (process.env.NODE_ENV !== 'production') {
-			if (typeof columnWidth !== 'number') {
-				throw Error('An invalid "columnWidth" prop has been specified. ' + 'Value should be a number. ' + `"${columnWidth === null ? 'null' : typeof columnWidth}" was specified.`);
-			}
-
-			if (typeof rowHeight !== 'number') {
-				throw Error('An invalid "rowHeight" prop has been specified. ' + 'Value should be a number. ' + `"${rowHeight === null ? 'null' : typeof rowHeight}" was specified.`);
-			}
-		}
-	},
-});
-
-export default FixedSizeGrid;
+// @flow
+
+import createGridComponent from './createGridComponent';
+
+import type { Props, ScrollToAlign } from './createGridComponent';
+
+const FixedSizeGrid = createGridComponent({
+	getColumnOffset: ({ columnWidth }: Props<any>, index: number): number => index * ((columnWidth: any): number),
+
+	getColumnWidth: ({ columnWidth }: Props<any>, index: number): number => ((columnWidth: any): number),
+
+	getRowOffset: ({ rowHeight }: Props<any>, index: number): number => index * ((rowHeight: any): number),
+
+	getRowHeight: ({ rowHeight }: Props<any>, index: number): number => ((rowHeight: any): number),
+
+	getEstimatedTotalHeight: ({ rowCount, rowHeight }: Props<any>) => ((rowHeight: any): number) * rowCount,
+
+	getEstimatedTotalWidth: ({ columnCount, columnWidth }: Props<any>) => ((columnWidth: any): number) * columnCount,
+
+	getOffsetForColumnAndAlignment: (
+		{ columnCount, columnWidth, width }: Props<any>,
+		columnIndex: number,
+		align: ScrollToAlign,
+		scrollLeft: number,
+		instanceProps: typeof undefined,
+		scrollbarSize: number,
+	): number => {
+		const lastColumnOffset = Math.max(0, columnCount * ((columnWidth: any): number) - width);
+		const maxOffset = Math.min(lastColumnOffset, columnIndex * ((columnWidth: any): number));
+		const minOffset = Math.max(0, columnIndex * ((columnWidth: any): number) - width + scrollbarSize + ((columnWidth: any): number));
+
+		if (align === 'smart') {
+			if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
+				align = 'auto';
+			} else {
+				align = 'center';
+			}
+		}
+
+		switch (align) {
+			case 'start':
+				return maxOffset;
+			case 'end':
+				return minOffset;
+			case 'center':
+				// "Centered" offset is usually the average of the min and max.
+				// But near the edges of the list, this doesn't hold true.
+				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+				if (middleOffset < Math.ceil(width / 2)) {
+					return 0; // near the beginning
+				} else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
+					return lastColumnOffset; // near the end
+				} else {
+					return middleOffset;
+				}
+			case 'auto':
+			default:
+				if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
+					return scrollLeft;
+				} else if (minOffset > maxOffset) {
+					// Because we only take into account the scrollbar size when calculating minOffset
+					// this value can be larger than maxOffset when at the end of the list
+					return minOffset;
+				} else if (scrollLeft < minOffset) {
+					return minOffset;
+				} else {
+					return maxOffset;
+				}
+		}
+	},
+
+	getOffsetForRowAndAlignment: (
+		{ rowHeight, height, rowCount }: Props<any>,
+		rowIndex: number,
+		align: ScrollToAlign,
+		scrollTop: number,
+		instanceProps: typeof undefined,
+		scrollbarSize: number,
+	): number => {
+		const lastRowOffset = Math.max(0, rowCount * ((rowHeight: any): number) - height);
+		const maxOffset = Math.min(lastRowOffset, rowIndex * ((rowHeight: any): number));
+		const minOffset = Math.max(0, rowIndex * ((rowHeight: any): number) - height + scrollbarSize + ((rowHeight: any): number));
+
+		if (align === 'smart') {
+			if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
+				align = 'auto';
+			} else {
+				align = 'center';
+			}
+		}
+
+		switch (align) {
+			case 'start':
+				return maxOffset;
+			case 'end':
+				return minOffset;
+			case 'center':
+				// "Centered" offset is usually the average of the min and max.
+				// But near the edges of the list, this doesn't hold true.
+				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+				if (middleOffset < Math.ceil(height / 2)) {
+					return 0; // near the beginning
+				} else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
+					return lastRowOffset; // near the end
+				} else {
+					return middleOffset;
+				}
+			case 'auto':
+			default:
+				if (scrollTop >= minOffset && scrollTop <= maxOffset) {
+					return scrollTop;
+				} else if (minOffset > maxOffset) {
+					// Because we only take into account the scrollbar size when calculating minOffset
+					// this value can be larger than maxOffset when at the end of the list
+					return minOffset;
+				} else if (scrollTop < minOffset) {
+					return minOffset;
+				} else {
+					return maxOffset;
+				}
+		}
+	},
+
+	getColumnStartIndexForOffset: ({ columnWidth, columnCount }: Props<any>, scrollLeft: number): number =>
+		Math.max(0, Math.min(columnCount - 1, Math.floor(scrollLeft / ((columnWidth: any): number)))),
+
+	getColumnStopIndexForStartIndex: ({ columnWidth, columnCount, width }: Props<any>, startIndex: number, scrollLeft: number): number => {
+		const left = startIndex * ((columnWidth: any): number);
+		const numVisibleColumns = Math.ceil((width + scrollLeft - left) / ((columnWidth: any): number));
+		return Math.max(
+			0,
+			Math.min(
+				columnCount - 1,
+				startIndex + numVisibleColumns - 1, // -1 is because stop index is inclusive
+			),
+		);
+	},
+
+	getRowStartIndexForOffset: ({ rowHeight, rowCount }: Props<any>, scrollTop: number): number => Math.max(0, Math.min(rowCount - 1, Math.floor(scrollTop / ((rowHeight: any): number)))),
+
+	getRowStopIndexForStartIndex: ({ rowHeight, rowCount, height }: Props<any>, startIndex: number, scrollTop: number): number => {
+		const top = startIndex * ((rowHeight: any): number);
+		const numVisibleRows = Math.ceil((height + scrollTop - top) / ((rowHeight: any): number));
+		return Math.max(
+			0,
+			Math.min(
+				rowCount - 1,
+				startIndex + numVisibleRows - 1, // -1 is because stop index is inclusive
+			),
+		);
+	},
+
+	initInstanceProps(props: Props<any>): any {
+		// Noop
+	},
+
+	shouldResetStyleCacheOnItemSizeChange: true,
+
+	validateProps: ({ columnWidth, rowHeight }: Props<any>): void => {
+		if (process.env.NODE_ENV !== 'production') {
+			if (typeof columnWidth !== 'number') {
+				throw Error('An invalid "columnWidth" prop has been specified. ' + 'Value should be a number. ' + `"${columnWidth === null ? 'null' : typeof columnWidth}" was specified.`);
+			}
+
+			if (typeof rowHeight !== 'number') {
+				throw Error('An invalid "rowHeight" prop has been specified. ' + 'Value should be a number. ' + `"${rowHeight === null ? 'null' : typeof rowHeight}" was specified.`);
+			}
+		}
+	},
+});
+
+export default FixedSizeGrid;

package/lib/react-window/src/FixedSizeList.js

@@ -1,91 +1,91 @@
-// @flow
-
-import createListComponent from './createListComponent';
-
-import type { Props, ScrollToAlign } from './createListComponent';
-
-const FixedSizeList = createListComponent({
-	getItemOffset: ({ itemSize }: Props<any>, index: number): number => index * ((itemSize: any): number),
-
-	getItemSize: ({ itemSize }: Props<any>, index: number): number => ((itemSize: any): number),
-
-	getEstimatedTotalSize: ({ itemCount, itemSize }: Props<any>) => ((itemSize: any): number) * itemCount,
-
-	getOffsetForIndexAndAlignment: ({ direction, height, itemCount, itemSize, layout, width }: Props<any>, index: number, align: ScrollToAlign, scrollOffset: number): number => {
-		// TODO Deprecate direction "horizontal"
-		const isHorizontal = direction === 'horizontal' || layout === 'horizontal';
-		const size = (((isHorizontal ? width : height): any): number);
-		const lastItemOffset = Math.max(0, itemCount * ((itemSize: any): number) - size);
-		const maxOffset = Math.min(lastItemOffset, index * ((itemSize: any): number));
-		const minOffset = Math.max(0, index * ((itemSize: any): number) - size + ((itemSize: any): number));
-
-		if (align === 'smart') {
-			if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
-				align = 'auto';
-			} else {
-				align = 'center';
-			}
-		}
-
-		switch (align) {
-			case 'start':
-				return maxOffset;
-			case 'end':
-				return minOffset;
-			case 'center': {
-				// "Centered" offset is usually the average of the min and max.
-				// But near the edges of the list, this doesn't hold true.
-				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
-				if (middleOffset < Math.ceil(size / 2)) {
-					return 0; // near the beginning
-				} else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
-					return lastItemOffset; // near the end
-				} else {
-					return middleOffset;
-				}
-			}
-			case 'auto':
-			default:
-				if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
-					return scrollOffset;
-				} else if (scrollOffset < minOffset) {
-					return minOffset;
-				} else {
-					return maxOffset;
-				}
-		}
-	},
-
-	getStartIndexForOffset: ({ itemCount, itemSize }: Props<any>, offset: number): number => Math.max(0, Math.min(itemCount - 1, Math.floor(offset / ((itemSize: any): number)))),
-
-	getStopIndexForStartIndex: ({ direction, height, itemCount, itemSize, layout, width }: Props<any>, startIndex: number, scrollOffset: number): number => {
-		// TODO Deprecate direction "horizontal"
-		const isHorizontal = direction === 'horizontal' || layout === 'horizontal';
-		const offset = startIndex * ((itemSize: any): number);
-		const size = (((isHorizontal ? width : height): any): number);
-		const numVisibleItems = Math.ceil((size + scrollOffset - offset) / ((itemSize: any): number));
-		return Math.max(
-			0,
-			Math.min(
-				itemCount - 1,
-				startIndex + numVisibleItems - 1, // -1 is because stop index is inclusive
-			),
-		);
-	},
-
-	initInstanceProps(props: Props<any>): any {
-		// Noop
-	},
-
-	shouldResetStyleCacheOnItemSizeChange: true,
-
-	validateProps: ({ itemSize }: Props<any>): void => {
-		if (process.env.NODE_ENV !== 'production') {
-			if (typeof itemSize !== 'number') {
-				throw Error('An invalid "itemSize" prop has been specified. ' + 'Value should be a number. ' + `"${itemSize === null ? 'null' : typeof itemSize}" was specified.`);
-			}
-		}
-	},
-});
-
-export default FixedSizeList;
+// @flow
+
+import createListComponent from './createListComponent';
+
+import type { Props, ScrollToAlign } from './createListComponent';
+
+const FixedSizeList = createListComponent({
+	getItemOffset: ({ itemSize }: Props<any>, index: number): number => index * ((itemSize: any): number),
+
+	getItemSize: ({ itemSize }: Props<any>, index: number): number => ((itemSize: any): number),
+
+	getEstimatedTotalSize: ({ itemCount, itemSize }: Props<any>) => ((itemSize: any): number) * itemCount,
+
+	getOffsetForIndexAndAlignment: ({ direction, height, itemCount, itemSize, layout, width }: Props<any>, index: number, align: ScrollToAlign, scrollOffset: number): number => {
+		// TODO Deprecate direction "horizontal"
+		const isHorizontal = direction === 'horizontal' || layout === 'horizontal';
+		const size = (((isHorizontal ? width : height): any): number);
+		const lastItemOffset = Math.max(0, itemCount * ((itemSize: any): number) - size);
+		const maxOffset = Math.min(lastItemOffset, index * ((itemSize: any): number));
+		const minOffset = Math.max(0, index * ((itemSize: any): number) - size + ((itemSize: any): number));
+
+		if (align === 'smart') {
+			if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
+				align = 'auto';
+			} else {
+				align = 'center';
+			}
+		}
+
+		switch (align) {
+			case 'start':
+				return maxOffset;
+			case 'end':
+				return minOffset;
+			case 'center': {
+				// "Centered" offset is usually the average of the min and max.
+				// But near the edges of the list, this doesn't hold true.
+				const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
+				if (middleOffset < Math.ceil(size / 2)) {
+					return 0; // near the beginning
+				} else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
+					return lastItemOffset; // near the end
+				} else {
+					return middleOffset;
+				}
+			}
+			case 'auto':
+			default:
+				if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
+					return scrollOffset;
+				} else if (scrollOffset < minOffset) {
+					return minOffset;
+				} else {
+					return maxOffset;
+				}
+		}
+	},
+
+	getStartIndexForOffset: ({ itemCount, itemSize }: Props<any>, offset: number): number => Math.max(0, Math.min(itemCount - 1, Math.floor(offset / ((itemSize: any): number)))),
+
+	getStopIndexForStartIndex: ({ direction, height, itemCount, itemSize, layout, width }: Props<any>, startIndex: number, scrollOffset: number): number => {
+		// TODO Deprecate direction "horizontal"
+		const isHorizontal = direction === 'horizontal' || layout === 'horizontal';
+		const offset = startIndex * ((itemSize: any): number);
+		const size = (((isHorizontal ? width : height): any): number);
+		const numVisibleItems = Math.ceil((size + scrollOffset - offset) / ((itemSize: any): number));
+		return Math.max(
+			0,
+			Math.min(
+				itemCount - 1,
+				startIndex + numVisibleItems - 1, // -1 is because stop index is inclusive
+			),
+		);
+	},
+
+	initInstanceProps(props: Props<any>): any {
+		// Noop
+	},
+
+	shouldResetStyleCacheOnItemSizeChange: true,
+
+	validateProps: ({ itemSize }: Props<any>): void => {
+		if (process.env.NODE_ENV !== 'production') {
+			if (typeof itemSize !== 'number') {
+				throw Error('An invalid "itemSize" prop has been specified. ' + 'Value should be a number. ' + `"${itemSize === null ? 'null' : typeof itemSize}" was specified.`);
+			}
+		}
+	},
+});
+
+export default FixedSizeList;