@fluentui/react-virtualizer 0.0.0-nightly-20230119-0422.1

package/lib-commonjs/Virtualizer.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const tslib_1 = /*#__PURE__*/require("tslib");
+tslib_1.__exportStar(require("./components/Virtualizer/index"), exports);
+//# sourceMappingURL=Virtualizer.js.map

package/lib-commonjs/Virtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;AAAAA","names":["tslib_1"],"sourceRoot":"","sources":["../../../../../../../packages/react-components/react-virtualizer/src/Virtualizer.ts"],"sourcesContent":["export * from './components/Virtualizer/index';\n"]}

package/lib-commonjs/components/Virtualizer/Virtualizer.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Virtualizer = void 0;
+const useVirtualizerStyles_1 = /*#__PURE__*/require("./useVirtualizerStyles");
+const useVirtualizer_1 = /*#__PURE__*/require("./useVirtualizer");
+const renderVirtualizer_1 = /*#__PURE__*/require("./renderVirtualizer");
+/**
+ * Virtualizer pseudo-component, this functional wrapper
+ * provides a simple interface for reducing the total number
+ * of elements rendered at one time in large lists.
+ */
+const Virtualizer = props => {
+  const state = useVirtualizer_1.useVirtualizer_unstable(props);
+  useVirtualizerStyles_1.useVirtualizerStyles_unstable(state);
+  return renderVirtualizer_1.renderVirtualizer_unstable(state);
+};
+exports.Virtualizer = Virtualizer;
+exports.Virtualizer.displayName = 'Virtualizer';
+//# sourceMappingURL=Virtualizer.js.map

package/lib-commonjs/components/Virtualizer/Virtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;AACA;AACA;AACA;AAGA;;;;;AAKO,MAAMA,WAAW,GAA0BC,KAAuB,IAAI;EAC3E,MAAMC,KAAK,GAAGC,wCAAuB,CAACF,KAAK,CAAC;EAC5CG,oDAA6B,CAACF,KAAK,CAAC;EAEpC,OAAOG,8CAA0B,CAACH,KAAK,CAAC;AAC1C,CAAC;AALYI,mBAAW;AAOxBA,mBAAW,CAACC,WAAW,GAAG,aAAa","names":["Virtualizer","props","state","useVirtualizer_1","useVirtualizerStyles_1","renderVirtualizer_1","exports","displayName"],"sourceRoot":"","sources":["../../../../../../../../../packages/react-components/react-virtualizer/src/components/Virtualizer/Virtualizer.ts"],"sourcesContent":["import type { VirtualizerProps } from './Virtualizer.types';\nimport { useVirtualizerStyles_unstable } from './useVirtualizerStyles';\nimport { useVirtualizer_unstable } from './useVirtualizer';\nimport { renderVirtualizer_unstable } from './renderVirtualizer';\nimport type { FC } from 'react';\n\n/**\n * Virtualizer pseudo-component, this functional wrapper\n * provides a simple interface for reducing the total number\n * of elements rendered at one time in large lists.\n */\nexport const Virtualizer: FC<VirtualizerProps> = (props: VirtualizerProps) => {\n  const state = useVirtualizer_unstable(props);\n  useVirtualizerStyles_unstable(state);\n\n  return renderVirtualizer_unstable(state);\n};\n\nVirtualizer.displayName = 'Virtualizer';\n"]}

package/lib-commonjs/components/Virtualizer/Virtualizer.types.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=Virtualizer.types.js.map

package/lib-commonjs/components/Virtualizer/Virtualizer.types.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/lib-commonjs/components/Virtualizer/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+const tslib_1 = /*#__PURE__*/require("tslib");
+tslib_1.__exportStar(require("./Virtualizer"), exports);
+tslib_1.__exportStar(require("./Virtualizer.types"), exports);
+tslib_1.__exportStar(require("./useVirtualizer"), exports);
+tslib_1.__exportStar(require("./renderVirtualizer"), exports);
+tslib_1.__exportStar(require("./useVirtualizerStyles"), exports);
+//# sourceMappingURL=index.js.map

package/lib-commonjs/components/Virtualizer/index.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;AAAAA;AACAA;AACAA;AACAA;AACAA","names":["tslib_1"],"sourceRoot":"","sources":["../../../../../../../../../packages/react-components/react-virtualizer/src/components/Virtualizer/index.ts"],"sourcesContent":["export * from './Virtualizer';\nexport * from './Virtualizer.types';\nexport * from './useVirtualizer';\nexport * from './renderVirtualizer';\nexport * from './useVirtualizerStyles';\n"]}

package/lib-commonjs/components/Virtualizer/renderVirtualizer.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.renderVirtualizer_unstable = void 0;
+const React = /*#__PURE__*/require("react");
+const react_utilities_1 = /*#__PURE__*/require("@fluentui/react-utilities");
+const renderVirtualizer_unstable = state => {
+  const {
+    slots,
+    slotProps
+  } = react_utilities_1.getSlots(state);
+  return React.createElement(React.Fragment, null, React.createElement(slots.beforeContainer, {
+    ...slotProps.beforeContainer
+  }, React.createElement(slots.before, {
+    ...slotProps.before
+  })), state.virtualizedChildren, React.createElement(slots.afterContainer, {
+    ...slotProps.afterContainer
+  }, React.createElement(slots.after, {
+    ...slotProps.after
+  })));
+};
+exports.renderVirtualizer_unstable = renderVirtualizer_unstable;
+//# sourceMappingURL=renderVirtualizer.js.map

package/lib-commonjs/components/Virtualizer/renderVirtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":";;;;;;AAAA;AACA;AAGO,MAAMA,0BAA0B,GAAIC,KAAuB,IAAI;EACpE,MAAM;IAAEC,KAAK;IAAEC;EAAS,CAAE,GAAGC,0BAAQ,CAAmBH,KAAK,CAAC;EAE9D,OACEI,oBAACA,KAAK,CAACC,QAAQ,QAEbD,oBAACH,KAAK,CAACK,eAAe;IAAA,GAAKJ,SAAS,CAACI;EAAe,GAClDF,oBAACH,KAAK,CAACM,MAAM;IAAA,GAAKL,SAAS,CAACK;EAAM,EAAI,CAChB,EAEvBP,KAAK,CAACQ,mBAAmB,EAE1BJ,oBAACH,KAAK,CAACQ,cAAc;IAAA,GAAKP,SAAS,CAACO;EAAc,GAChDL,oBAACH,KAAK,CAACS,KAAK;IAAA,GAAKR,SAAS,CAACQ;EAAK,EAAI,CACf,CACR;AAErB,CAAC;AAjBYC,kCAA0B","names":["renderVirtualizer_unstable","state","slots","slotProps","react_utilities_1","React","Fragment","beforeContainer","before","virtualizedChildren","afterContainer","after","exports"],"sourceRoot":"","sources":["../../../../../../../../../packages/react-components/react-virtualizer/src/components/Virtualizer/renderVirtualizer.tsx"],"sourcesContent":["import * as React from 'react';\nimport { getSlots } from '@fluentui/react-utilities';\nimport { VirtualizerSlots, VirtualizerState } from './Virtualizer.types';\n\nexport const renderVirtualizer_unstable = (state: VirtualizerState) => {\n  const { slots, slotProps } = getSlots<VirtualizerSlots>(state);\n\n  return (\n    <React.Fragment>\n      {/* The 'before' bookend to hold items in place and detect scroll previous */}\n      <slots.beforeContainer {...slotProps.beforeContainer}>\n        <slots.before {...slotProps.before} />\n      </slots.beforeContainer>\n      {/* The reduced list of non-virtualized children to be rendered */}\n      {state.virtualizedChildren}\n      {/* The 'after' bookend to hold items in place and detect scroll next */}\n      <slots.afterContainer {...slotProps.afterContainer}>\n        <slots.after {...slotProps.after} />\n      </slots.afterContainer>\n    </React.Fragment>\n  );\n};\n"]}

package/lib-commonjs/components/Virtualizer/useVirtualizer.js

@@ -0,0 +1,370 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useVirtualizer_unstable = void 0;
+const useIntersectionObserver_1 = /*#__PURE__*/require("../../hooks/useIntersectionObserver");
+const react_1 = /*#__PURE__*/require("react");
+const react_utilities_1 = /*#__PURE__*/require("@fluentui/react-utilities");
+const react_dom_1 = /*#__PURE__*/require("react-dom");
+function useVirtualizer_unstable(props) {
+  const {
+    itemSize,
+    numItems,
+    virtualizerLength,
+    children: renderChild,
+    getItemSize,
+    bufferItems = Math.round(virtualizerLength / 4.0),
+    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,
+    intersectionObserverRoot,
+    axis = 'vertical',
+    reversed = false,
+    onUpdateIndex,
+    onCalculateIndex
+  } = props;
+  // Tracks the initial item to start virtualizer at, -1 implies first render cycle
+  const [virtualizerStartIndex, setVirtualizerStartIndex] = react_1.useState(-1);
+  // Store ref to before padding element
+  const beforeElementRef = react_1.useRef(null);
+  // Store ref to before padding element
+  const afterElementRef = react_1.useRef(null);
+  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes
+  const childSizes = react_1.useRef(new Array(getItemSize ? numItems : 0));
+  /* We keep track of the progressive sizing/placement down the list,
+  this helps us skip re-calculations unless children/size changes */
+  const childProgressiveSizes = react_1.useRef(new Array(getItemSize ? numItems : 0));
+  // The internal tracking REF for child array (updates often).
+  const childArray = react_1.useRef(new Array(virtualizerLength));
+  // We want to be methodical about updating the render with child reference array
+  const forceUpdate = react_1.useReducer(() => ({}), {})[1];
+  const horizontal = axis === 'horizontal';
+  const populateSizeArrays = () => {
+    if (!getItemSize) {
+      // Static sizes, never mind!
+      return;
+    }
+    if (numItems !== childSizes.current.length) {
+      childSizes.current = new Array(numItems);
+    }
+    if (numItems !== childProgressiveSizes.current.length) {
+      childProgressiveSizes.current = new Array(numItems);
+    }
+    for (let index = 0; index < numItems; index++) {
+      childSizes.current[index] = getItemSize(index);
+      if (index === 0) {
+        childProgressiveSizes.current[index] = childSizes.current[index];
+      } else {
+        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];
+      }
+    }
+  };
+  const batchUpdateNewIndex = index => {
+    // Local updates
+    onUpdateIndex === null || onUpdateIndex === void 0 ? void 0 : onUpdateIndex(index, virtualizerStartIndex);
+    updateChildRows(index);
+    updateCurrentItemSizes(index);
+    // State setters
+    setVirtualizerStartIndex(index);
+  };
+  // Observe intersections of virtualized components
+  const {
+    setObserverList
+  } = useIntersectionObserver_1.useIntersectionObserver((entries, observer) => {
+    /* Sanity check - do we even need virtualization? */
+    if (virtualizerLength > numItems) {
+      if (virtualizerStartIndex !== 0) {
+        batchUpdateNewIndex(0);
+      }
+      // No-op
+      return;
+    }
+    /* IO initiates this function when needed (bookend entering view) */
+    let measurementPos = 0;
+    let bufferCount = bufferItems;
+    // Grab latest entry that is intersecting
+    const latestEntry = entries.length === 1 ? entries[0] : entries.sort((entry1, entry2) => entry2.time - entry1.time).find(entry => {
+      return entry.intersectionRatio > 0;
+    });
+    if (!latestEntry) {
+      // If we don't find an intersecting area, ignore for now.
+      return;
+    }
+    if (latestEntry.target === afterElementRef.current) {
+      // We need to inverse the buffer count
+      bufferCount = virtualizerLength - bufferItems;
+      measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();
+      if (!horizontal) {
+        if (reversed) {
+          // Scrolling 'up' and hit the after element below
+          measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);
+        } else if (latestEntry.boundingClientRect.top < 0) {
+          // Scrolling 'down' and hit the after element above top: 0
+          measurementPos -= latestEntry.boundingClientRect.top;
+        }
+      } else {
+        if (reversed) {
+          // Scrolling 'left' and hit the after element
+          measurementPos -= Math.abs(latestEntry.boundingClientRect.right);
+        } else if (latestEntry.boundingClientRect.left < 0) {
+          // Scrolling 'right' and hit the after element
+          measurementPos -= latestEntry.boundingClientRect.left;
+        }
+      }
+    } else if (latestEntry.target === beforeElementRef.current) {
+      measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();
+      if (!horizontal) {
+        if (!reversed) {
+          measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);
+        } else if (latestEntry.boundingClientRect.top < 0) {
+          // Scrolling 'down' in reverse order and hit the before element above top: 0
+          measurementPos -= latestEntry.boundingClientRect.top;
+        }
+      } else {
+        if (!reversed) {
+          measurementPos -= Math.abs(latestEntry.boundingClientRect.right);
+        } else if (latestEntry.boundingClientRect.left < 0) {
+          // Scrolling 'left' and hit before element
+          measurementPos -= latestEntry.boundingClientRect.left;
+        }
+      }
+    }
+    if (reversed) {
+      // We're reversed, up is down, left is right, invert the scroll measure.
+      measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);
+    }
+    // For now lets use hardcoded size to assess current element to paginate on
+    const startIndex = getIndexFromScrollPosition(measurementPos);
+    let bufferedIndex = Math.max(startIndex - bufferCount, 0);
+    if (onCalculateIndex) {
+      // User has chance to intervene/customize prior to render
+      // They may want to normalize this value.
+      bufferedIndex = onCalculateIndex(bufferedIndex);
+    }
+    // Safety limits
+    const maxIndex = Math.max(numItems - virtualizerLength, 0);
+    const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);
+    if (virtualizerStartIndex !== newStartIndex) {
+      // We flush sync this and perform an immediate state update
+      // due to virtualizerStartIndex invalidation.
+      react_dom_1.flushSync(() => {
+        batchUpdateNewIndex(newStartIndex);
+      });
+    }
+  }, {
+    root: intersectionObserverRoot ? intersectionObserverRoot === null || intersectionObserverRoot === void 0 ? void 0 : intersectionObserverRoot.current : null,
+    rootMargin: '0px',
+    threshold: 0
+  });
+  const findIndexRecursive = (scrollPos, lowIndex, highIndex) => {
+    if (lowIndex > highIndex) {
+      // We shouldn't get here - but no-op the index if we do.
+      return virtualizerStartIndex;
+    }
+    const midpoint = Math.floor((lowIndex + highIndex) / 2);
+    const iBefore = Math.max(midpoint - 1, 0);
+    const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);
+    const indexValue = childProgressiveSizes.current[midpoint];
+    const afterIndexValue = childProgressiveSizes.current[iAfter];
+    const beforeIndexValue = childProgressiveSizes.current[iBefore];
+    if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {
+      /* We've found our index - if we are exactly matching before/after index that's ok,
+      better to reduce checks if it's right on the boundary. */
+      return midpoint;
+    }
+    if (indexValue > scrollPos) {
+      return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);
+    } else {
+      return findIndexRecursive(scrollPos, midpoint + 1, highIndex);
+    }
+  };
+  const getIndexFromSizeArray = scrollPos => {
+    /* Quick searches our progressive height array */
+    if (scrollPos === 0 || childProgressiveSizes.current.length === 0 || scrollPos <= childProgressiveSizes.current[0]) {
+      // Check start
+      return 0;
+    }
+    if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {
+      // Check end
+      return childProgressiveSizes.current.length - 1;
+    }
+    return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);
+  };
+  const getIndexFromScrollPosition = scrollPos => {
+    if (!getItemSize) {
+      return Math.round(scrollPos / itemSize);
+    }
+    return getIndexFromSizeArray(scrollPos);
+  };
+  const calculateTotalSize = () => {
+    if (!getItemSize) {
+      return itemSize * numItems;
+    }
+    // Time for custom size calcs
+    return childProgressiveSizes.current[numItems - 1];
+  };
+  const calculateBefore = () => {
+    if (!getItemSize) {
+      // The missing items from before virtualization starts height
+      return virtualizerStartIndex * itemSize;
+    }
+    if (virtualizerStartIndex <= 0) {
+      return 0;
+    }
+    // Time for custom size calcs
+    return childProgressiveSizes.current[virtualizerStartIndex - 1];
+  };
+  const calculateAfter = () => {
+    if (numItems === 0) {
+      return 0;
+    }
+    const lastItemIndex = Math.min(virtualizerStartIndex + virtualizerLength, numItems - 1);
+    if (!getItemSize) {
+      // The missing items from after virtualization ends height
+      const remainingItems = numItems - lastItemIndex - 1;
+      return remainingItems * itemSize;
+    }
+    // Time for custom size calcs
+    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];
+  };
+  const updateChildRows = newIndex => {
+    if (numItems === 0) {
+      /* Nothing to virtualize */
+      return [];
+    }
+    if (childArray.current.length !== numItems) {
+      childArray.current = new Array(virtualizerLength);
+    }
+    const actualIndex = Math.max(newIndex, 0);
+    const end = Math.min(actualIndex + virtualizerLength, numItems);
+    for (let i = actualIndex; i < end; i++) {
+      childArray.current[i - actualIndex] = renderChild(i);
+    }
+  };
+  const setBeforeRef = react_1.useCallback(element => {
+    if (!element || beforeElementRef.current === element) {
+      return;
+    }
+    beforeElementRef.current = element;
+    const newList = [];
+    newList.push(beforeElementRef.current);
+    if (afterElementRef.current) {
+      newList.push(afterElementRef.current);
+    }
+    // Ensure we update array if before element changed
+    setObserverList(newList);
+  }, [setObserverList]);
+  const setAfterRef = react_1.useCallback(element => {
+    if (!element || afterElementRef.current === element) {
+      return;
+    }
+    afterElementRef.current = element;
+    const newList = [];
+    if (beforeElementRef.current) {
+      newList.push(beforeElementRef.current);
+    }
+    newList.push(afterElementRef.current);
+    // Ensure we update array if after element changed
+    setObserverList(newList);
+  }, [setObserverList]);
+  const updateCurrentItemSizes = newIndex => {
+    if (!getItemSize) {
+      // Static sizes, not required.
+      return;
+    }
+    // We should always call our size function on index change (only for the items that will be rendered)
+    // This ensures we request the latest data for incoming items in case sizing has changed.
+    const endIndex = Math.min(newIndex + virtualizerLength, numItems);
+    const startIndex = Math.max(newIndex, 0);
+    let didUpdate = false;
+    for (let i = startIndex; i < endIndex; i++) {
+      const newSize = getItemSize(i);
+      if (newSize !== childSizes.current[i]) {
+        childSizes.current[i] = newSize;
+        didUpdate = true;
+      }
+    }
+    if (didUpdate) {
+      // Update our progressive size array
+      for (let i = startIndex; i < numItems; i++) {
+        const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;
+        childProgressiveSizes.current[i] = prevSize + childSizes.current[i];
+      }
+    }
+  };
+  // Initialize the size array before first render.
+  const hasInitialized = react_1.useRef(false);
+  const initializeSizeArray = () => {
+    if (hasInitialized.current === false) {
+      hasInitialized.current = true;
+      populateSizeArrays();
+    }
+  };
+  // Initialization on mount - update array index to 0 (ready state).
+  // Only fire on mount (no deps).
+  react_1.useEffect(() => {
+    if (virtualizerStartIndex < 0) {
+      batchUpdateNewIndex(0);
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+  // If the user passes in an updated renderChild function - update current children
+  react_1.useEffect(() => {
+    if (virtualizerStartIndex >= 0) {
+      updateChildRows(virtualizerStartIndex);
+      forceUpdate();
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [renderChild]);
+  // Ensure we have run through and updated the whole size list array at least once.
+  initializeSizeArray();
+  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {
+    // Child length mismatch, repopulate size arrays.
+    populateSizeArrays();
+  }
+  const isFullyInitialized = hasInitialized.current && virtualizerStartIndex >= 0;
+  return {
+    components: {
+      before: 'div',
+      after: 'div',
+      beforeContainer: 'div',
+      afterContainer: 'div'
+    },
+    virtualizedChildren: childArray.current,
+    before: react_utilities_1.resolveShorthand(props.before, {
+      required: true,
+      defaultProps: {
+        ref: setBeforeRef,
+        role: 'none'
+      }
+    }),
+    after: react_utilities_1.resolveShorthand(props.after, {
+      required: true,
+      defaultProps: {
+        ref: setAfterRef,
+        role: 'none'
+      }
+    }),
+    beforeContainer: react_utilities_1.resolveShorthand(props.beforeContainer, {
+      required: true,
+      defaultProps: {
+        role: 'none'
+      }
+    }),
+    afterContainer: react_utilities_1.resolveShorthand(props.afterContainer, {
+      required: true,
+      defaultProps: {
+        role: 'none'
+      }
+    }),
+    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,
+    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,
+    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,
+    virtualizerStartIndex,
+    axis,
+    bufferSize,
+    reversed
+  };
+}
+exports.useVirtualizer_unstable = useVirtualizer_unstable;
+//# sourceMappingURL=useVirtualizer.js.map

package/lib-commonjs/components/Virtualizer/useVirtualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"mappings":"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","names":["useVirtualizer_unstable","props","itemSize","numItems","virtualizerLength","children","renderChild","getItemSize","bufferItems","Math","round","bufferSize","floor","intersectionObserverRoot","axis","reversed","onUpdateIndex","onCalculateIndex","virtualizerStartIndex","setVirtualizerStartIndex","react_1","beforeElementRef","afterElementRef","childSizes","Array","childProgressiveSizes","childArray","forceUpdate","horizontal","populateSizeArrays","current","length","index","batchUpdateNewIndex","updateChildRows","updateCurrentItemSizes","setObserverList","useIntersectionObserver_1","entries","observer","measurementPos","bufferCount","latestEntry","sort","entry1","entry2","time","find","entry","intersectionRatio","target","calculateAfter","calculateTotalSize","abs","boundingClientRect","bottom","top","right","left","calculateBefore","max","startIndex","getIndexFromScrollPosition","bufferedIndex","maxIndex","newStartIndex","min","react_dom_1","root","rootMargin","threshold","findIndexRecursive","scrollPos","lowIndex","highIndex","midpoint","iBefore","iAfter","indexValue","afterIndexValue","beforeIndexValue","getIndexFromSizeArray","lastItemIndex","remainingItems","newIndex","actualIndex","end","i","setBeforeRef","element","newList","push","setAfterRef","endIndex","didUpdate","newSize","prevSize","hasInitialized","initializeSizeArray","isFullyInitialized","components","before","after","beforeContainer","afterContainer","virtualizedChildren","react_utilities_1","required","defaultProps","ref","role","beforeBufferHeight","afterBufferHeight","totalVirtualizerHeight","exports"],"sourceRoot":"","sources":["../../../../../../../../../packages/react-components/react-virtualizer/src/components/Virtualizer/useVirtualizer.ts"],"sourcesContent":["import { useIntersectionObserver } from '../../hooks/useIntersectionObserver';\nimport type { ReactNode } from 'react';\nimport { useEffect, useRef, useState, useCallback, useReducer } from 'react';\n\nimport type { VirtualizerProps, VirtualizerState } from './Virtualizer.types';\nimport { resolveShorthand } from '@fluentui/react-utilities';\nimport { flushSync } from 'react-dom';\n\nexport function useVirtualizer_unstable(props: VirtualizerProps): VirtualizerState {\n  const {\n    itemSize,\n    numItems,\n    virtualizerLength,\n    children: renderChild,\n    getItemSize,\n    bufferItems = Math.round(virtualizerLength / 4.0),\n    bufferSize = Math.floor(bufferItems / 2.0) * itemSize,\n    intersectionObserverRoot,\n    axis = 'vertical',\n    reversed = false,\n    onUpdateIndex,\n    onCalculateIndex,\n  } = props;\n\n  // Tracks the initial item to start virtualizer at, -1 implies first render cycle\n  const [virtualizerStartIndex, setVirtualizerStartIndex] = useState<number>(-1);\n\n  // Store ref to before padding element\n  const beforeElementRef = useRef<Element | null>(null);\n\n  // Store ref to before padding element\n  const afterElementRef = useRef<Element | null>(null);\n\n  // We need to store an array to track dynamic sizes, we can use this to incrementally update changes\n  const childSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  /* We keep track of the progressive sizing/placement down the list,\n  this helps us skip re-calculations unless children/size changes */\n  const childProgressiveSizes = useRef<number[]>(new Array<number>(getItemSize ? numItems : 0));\n\n  // The internal tracking REF for child array (updates often).\n  const childArray = useRef<ReactNode[]>(new Array(virtualizerLength));\n\n  // We want to be methodical about updating the render with child reference array\n  const forceUpdate = useReducer(() => ({}), {})[1];\n\n  const horizontal = axis === 'horizontal';\n\n  const populateSizeArrays = () => {\n    if (!getItemSize) {\n      // Static sizes, never mind!\n      return;\n    }\n\n    if (numItems !== childSizes.current.length) {\n      childSizes.current = new Array<number>(numItems);\n    }\n\n    if (numItems !== childProgressiveSizes.current.length) {\n      childProgressiveSizes.current = new Array<number>(numItems);\n    }\n\n    for (let index = 0; index < numItems; index++) {\n      childSizes.current[index] = getItemSize(index);\n\n      if (index === 0) {\n        childProgressiveSizes.current[index] = childSizes.current[index];\n      } else {\n        childProgressiveSizes.current[index] = childProgressiveSizes.current[index - 1] + childSizes.current[index];\n      }\n    }\n  };\n\n  const batchUpdateNewIndex = (index: number) => {\n    // Local updates\n    onUpdateIndex?.(index, virtualizerStartIndex);\n    updateChildRows(index);\n    updateCurrentItemSizes(index);\n\n    // State setters\n    setVirtualizerStartIndex(index);\n  };\n\n  // Observe intersections of virtualized components\n  const { setObserverList } = useIntersectionObserver(\n    (entries: IntersectionObserverEntry[], observer: IntersectionObserver) => {\n      /* Sanity check - do we even need virtualization? */\n      if (virtualizerLength > numItems) {\n        if (virtualizerStartIndex !== 0) {\n          batchUpdateNewIndex(0);\n        }\n        // No-op\n        return;\n      }\n\n      /* IO initiates this function when needed (bookend entering view) */\n      let measurementPos = 0;\n      let bufferCount = bufferItems;\n\n      // Grab latest entry that is intersecting\n      const latestEntry =\n        entries.length === 1\n          ? entries[0]\n          : entries\n              .sort((entry1, entry2) => entry2.time - entry1.time)\n              .find(entry => {\n                return entry.intersectionRatio > 0;\n              });\n\n      if (!latestEntry) {\n        // If we don't find an intersecting area, ignore for now.\n        return;\n      }\n\n      if (latestEntry.target === afterElementRef.current) {\n        // We need to inverse the buffer count\n        bufferCount = virtualizerLength - bufferItems;\n        measurementPos = reversed ? calculateAfter() : calculateTotalSize() - calculateAfter();\n        if (!horizontal) {\n          if (reversed) {\n            // Scrolling 'up' and hit the after element below\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' and hit the after element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (reversed) {\n            // Scrolling 'left' and hit the after element\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'right' and hit the after element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      } else if (latestEntry.target === beforeElementRef.current) {\n        measurementPos = reversed ? calculateTotalSize() - calculateBefore() : calculateBefore();\n        if (!horizontal) {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.bottom);\n          } else if (latestEntry.boundingClientRect.top < 0) {\n            // Scrolling 'down' in reverse order and hit the before element above top: 0\n            measurementPos -= latestEntry.boundingClientRect.top;\n          }\n        } else {\n          if (!reversed) {\n            measurementPos -= Math.abs(latestEntry.boundingClientRect.right);\n          } else if (latestEntry.boundingClientRect.left < 0) {\n            // Scrolling 'left' and hit before element\n            measurementPos -= latestEntry.boundingClientRect.left;\n          }\n        }\n      }\n\n      if (reversed) {\n        // We're reversed, up is down, left is right, invert the scroll measure.\n        measurementPos = Math.max(calculateTotalSize() - Math.abs(measurementPos), 0);\n      }\n\n      // For now lets use hardcoded size to assess current element to paginate on\n      const startIndex = getIndexFromScrollPosition(measurementPos);\n      let bufferedIndex = Math.max(startIndex - bufferCount, 0);\n\n      if (onCalculateIndex) {\n        // User has chance to intervene/customize prior to render\n        // They may want to normalize this value.\n        bufferedIndex = onCalculateIndex(bufferedIndex);\n      }\n\n      // Safety limits\n      const maxIndex = Math.max(numItems - virtualizerLength, 0);\n      const newStartIndex = Math.min(Math.max(bufferedIndex, 0), maxIndex);\n\n      if (virtualizerStartIndex !== newStartIndex) {\n        // We flush sync this and perform an immediate state update\n        // due to virtualizerStartIndex invalidation.\n        flushSync(() => {\n          batchUpdateNewIndex(newStartIndex);\n        });\n      }\n    },\n    {\n      root: intersectionObserverRoot ? intersectionObserverRoot?.current : null,\n      rootMargin: '0px',\n      threshold: 0,\n    },\n  );\n\n  const findIndexRecursive = (scrollPos: number, lowIndex: number, highIndex: number): number => {\n    if (lowIndex > highIndex) {\n      // We shouldn't get here - but no-op the index if we do.\n      return virtualizerStartIndex;\n    }\n    const midpoint = Math.floor((lowIndex + highIndex) / 2);\n    const iBefore = Math.max(midpoint - 1, 0);\n    const iAfter = Math.min(midpoint + 1, childProgressiveSizes.current.length - 1);\n    const indexValue = childProgressiveSizes.current[midpoint];\n    const afterIndexValue = childProgressiveSizes.current[iAfter];\n    const beforeIndexValue = childProgressiveSizes.current[iBefore];\n    if (scrollPos <= afterIndexValue && scrollPos >= beforeIndexValue) {\n      /* We've found our index - if we are exactly matching before/after index that's ok,\n      better to reduce checks if it's right on the boundary. */\n      return midpoint;\n    }\n\n    if (indexValue > scrollPos) {\n      return findIndexRecursive(scrollPos, lowIndex, midpoint - 1);\n    } else {\n      return findIndexRecursive(scrollPos, midpoint + 1, highIndex);\n    }\n  };\n\n  const getIndexFromSizeArray = (scrollPos: number): number => {\n    /* Quick searches our progressive height array */\n    if (\n      scrollPos === 0 ||\n      childProgressiveSizes.current.length === 0 ||\n      scrollPos <= childProgressiveSizes.current[0]\n    ) {\n      // Check start\n      return 0;\n    }\n\n    if (scrollPos >= childProgressiveSizes.current[childProgressiveSizes.current.length - 1]) {\n      // Check end\n      return childProgressiveSizes.current.length - 1;\n    }\n\n    return findIndexRecursive(scrollPos, 0, childProgressiveSizes.current.length - 1);\n  };\n\n  const getIndexFromScrollPosition = (scrollPos: number) => {\n    if (!getItemSize) {\n      return Math.round(scrollPos / itemSize);\n    }\n\n    return getIndexFromSizeArray(scrollPos);\n  };\n\n  const calculateTotalSize = () => {\n    if (!getItemSize) {\n      return itemSize * numItems;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1];\n  };\n\n  const calculateBefore = () => {\n    if (!getItemSize) {\n      // The missing items from before virtualization starts height\n      return virtualizerStartIndex * itemSize;\n    }\n\n    if (virtualizerStartIndex <= 0) {\n      return 0;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[virtualizerStartIndex - 1];\n  };\n\n  const calculateAfter = () => {\n    if (numItems === 0) {\n      return 0;\n    }\n\n    const lastItemIndex = Math.min(virtualizerStartIndex + virtualizerLength, numItems - 1);\n    if (!getItemSize) {\n      // The missing items from after virtualization ends height\n      const remainingItems = numItems - lastItemIndex - 1;\n      return remainingItems * itemSize;\n    }\n\n    // Time for custom size calcs\n    return childProgressiveSizes.current[numItems - 1] - childProgressiveSizes.current[lastItemIndex];\n  };\n\n  const updateChildRows = (newIndex: number) => {\n    if (numItems === 0) {\n      /* Nothing to virtualize */\n\n      return [];\n    }\n\n    if (childArray.current.length !== numItems) {\n      childArray.current = new Array(virtualizerLength);\n    }\n    const actualIndex = Math.max(newIndex, 0);\n    const end = Math.min(actualIndex + virtualizerLength, numItems);\n\n    for (let i = actualIndex; i < end; i++) {\n      childArray.current[i - actualIndex] = renderChild(i);\n    }\n  };\n\n  const setBeforeRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || beforeElementRef.current === element) {\n        return;\n      }\n      beforeElementRef.current = element;\n      const newList = [];\n\n      newList.push(beforeElementRef.current);\n\n      if (afterElementRef.current) {\n        newList.push(afterElementRef.current);\n      }\n\n      // Ensure we update array if before element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const setAfterRef = useCallback(\n    (element: HTMLDivElement) => {\n      if (!element || afterElementRef.current === element) {\n        return;\n      }\n      afterElementRef.current = element;\n      const newList = [];\n\n      if (beforeElementRef.current) {\n        newList.push(beforeElementRef.current);\n      }\n\n      newList.push(afterElementRef.current);\n\n      // Ensure we update array if after element changed\n      setObserverList(newList);\n    },\n    [setObserverList],\n  );\n\n  const updateCurrentItemSizes = (newIndex: number) => {\n    if (!getItemSize) {\n      // Static sizes, not required.\n      return;\n    }\n    // We should always call our size function on index change (only for the items that will be rendered)\n    // This ensures we request the latest data for incoming items in case sizing has changed.\n    const endIndex = Math.min(newIndex + virtualizerLength, numItems);\n    const startIndex = Math.max(newIndex, 0);\n\n    let didUpdate = false;\n    for (let i = startIndex; i < endIndex; i++) {\n      const newSize = getItemSize(i);\n      if (newSize !== childSizes.current[i]) {\n        childSizes.current[i] = newSize;\n        didUpdate = true;\n      }\n    }\n\n    if (didUpdate) {\n      // Update our progressive size array\n      for (let i = startIndex; i < numItems; i++) {\n        const prevSize = i > 0 ? childProgressiveSizes.current[i - 1] : 0;\n        childProgressiveSizes.current[i] = prevSize + childSizes.current[i];\n      }\n    }\n  };\n\n  // Initialize the size array before first render.\n  const hasInitialized = useRef<boolean>(false);\n  const initializeSizeArray = () => {\n    if (hasInitialized.current === false) {\n      hasInitialized.current = true;\n      populateSizeArrays();\n    }\n  };\n\n  // Initialization on mount - update array index to 0 (ready state).\n  // Only fire on mount (no deps).\n  useEffect(() => {\n    if (virtualizerStartIndex < 0) {\n      batchUpdateNewIndex(0);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  // If the user passes in an updated renderChild function - update current children\n  useEffect(() => {\n    if (virtualizerStartIndex >= 0) {\n      updateChildRows(virtualizerStartIndex);\n      forceUpdate();\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [renderChild]);\n\n  // Ensure we have run through and updated the whole size list array at least once.\n  initializeSizeArray();\n\n  if (getItemSize && (numItems !== childSizes.current.length || numItems !== childProgressiveSizes.current.length)) {\n    // Child length mismatch, repopulate size arrays.\n    populateSizeArrays();\n  }\n\n  const isFullyInitialized = hasInitialized.current && virtualizerStartIndex >= 0;\n  return {\n    components: {\n      before: 'div',\n      after: 'div',\n      beforeContainer: 'div',\n      afterContainer: 'div',\n    },\n    virtualizedChildren: childArray.current,\n    before: resolveShorthand(props.before, {\n      required: true,\n      defaultProps: {\n        ref: setBeforeRef,\n        role: 'none',\n      },\n    }),\n    after: resolveShorthand(props.after, {\n      required: true,\n      defaultProps: {\n        ref: setAfterRef,\n        role: 'none',\n      },\n    }),\n    beforeContainer: resolveShorthand(props.beforeContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    afterContainer: resolveShorthand(props.afterContainer, {\n      required: true,\n      defaultProps: {\n        role: 'none',\n      },\n    }),\n    beforeBufferHeight: isFullyInitialized ? calculateBefore() : 0,\n    afterBufferHeight: isFullyInitialized ? calculateAfter() : 0,\n    totalVirtualizerHeight: isFullyInitialized ? calculateTotalSize() : virtualizerLength * itemSize,\n    virtualizerStartIndex,\n    axis,\n    bufferSize,\n    reversed,\n  };\n}\n"]}

package/lib-commonjs/components/Virtualizer/useVirtualizerStyles.js

@@ -0,0 +1,115 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useVirtualizerStyles_unstable = exports.virtualizerClassNames = void 0;
+const react_1 = /*#__PURE__*/require("@griffel/react");
+const virtualizerClassName = 'fui-Virtualizer';
+exports.virtualizerClassNames = {
+  before: `${virtualizerClassName}__before`,
+  beforeContainer: `${virtualizerClassName}__beforeContainer`,
+  after: `${virtualizerClassName}__after`,
+  afterContainer: `${virtualizerClassName}__afterContainer`
+};
+const useStyles = /*#__PURE__*/react_1.__styles({
+  base: {
+    mc9l5x: "ftgm304",
+    Bkecrkj: "f1aehjj5"
+  },
+  relative: {
+    qhf8xq: "f10pi13n"
+  },
+  horizontal: {
+    sshi5w: "fan4evk"
+  },
+  vertical: {
+    Bf4jedk: "f11qra4b"
+  }
+}, {
+  d: [".ftgm304{display:block;}", ".f1aehjj5{pointer-events:none;}", ".f10pi13n{position:relative;}", ".fan4evk{min-height:100%;}", ".f11qra4b{min-width:100%;}"]
+});
+/**
+ * Apply styling to the Virtualizer states
+ */
+const useVirtualizerStyles_unstable = state => {
+  const styles = useStyles();
+  const {
+    reversed,
+    axis,
+    beforeBufferHeight,
+    afterBufferHeight,
+    bufferSize
+  } = state;
+  const horizontal = axis === 'horizontal';
+  state.before.className = react_1.mergeClasses(exports.virtualizerClassNames.before, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.before.className);
+  state.after.className = react_1.mergeClasses(exports.virtualizerClassNames.after, styles.base, styles.relative, horizontal ? styles.horizontal : styles.vertical, state.after.className);
+  state.beforeContainer.className = react_1.mergeClasses(exports.virtualizerClassNames.beforeContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.beforeContainer.className);
+  state.afterContainer.className = react_1.mergeClasses(exports.virtualizerClassNames.afterContainer, styles.base, horizontal ? styles.horizontal : styles.vertical, state.afterContainer.className);
+  const beforeHeightPx = beforeBufferHeight + 'px';
+  const afterHeightPx = afterBufferHeight + 'px';
+  const beforeBufferHeightPx = beforeBufferHeight + bufferSize + 'px';
+  const afterBufferHeightPx = afterBufferHeight + bufferSize + 'px';
+  const bufferPx = bufferSize + 'px';
+  const beforeBuffer = {
+    // Column
+    ...(!reversed && !horizontal && {
+      marginBottom: `-${bufferPx}`
+    }),
+    // Column-Reverse
+    ...(reversed && !horizontal && {
+      marginTop: `-${bufferPx}`
+    }),
+    // Row
+    ...(!reversed && horizontal && {
+      marginLeft: `-${bufferPx}`
+    }),
+    // Row-Reverse
+    ...(reversed && horizontal && {
+      marginRight: `-${bufferPx}`
+    })
+  };
+  const afterBuffer = {
+    // Column
+    ...(!reversed && !horizontal && {
+      marginTop: `-${bufferPx}`
+    }),
+    // Column-Reverse
+    ...(reversed && !horizontal && {
+      marginBottom: `-${bufferPx}`
+    }),
+    // Row
+    ...(!reversed && horizontal && {
+      marginLeft: `-${bufferPx}`
+    }),
+    // Row-Reverse
+    ...(reversed && horizontal && {
+      marginRight: `-${bufferPx}`
+    })
+  };
+  state.before.style = {
+    height: horizontal ? '100%' : beforeBufferHeightPx,
+    width: horizontal ? beforeBufferHeightPx : '100%',
+    ...beforeBuffer,
+    ...state.before.style
+  };
+  state.beforeContainer.style = {
+    height: horizontal ? 'auto' : beforeHeightPx,
+    width: horizontal ? beforeHeightPx : 'auto',
+    ...state.beforeContainer.style
+  };
+  state.after.style = {
+    height: horizontal ? '100%' : afterBufferHeightPx,
+    width: horizontal ? afterBufferHeightPx : '100%',
+    ...afterBuffer,
+    ...state.after.style
+  };
+  state.afterContainer.style = {
+    height: horizontal ? 'auto' : afterHeightPx,
+    width: horizontal ? afterHeightPx : 'auto',
+    ...state.afterContainer.style
+  };
+  return state;
+};
+exports.useVirtualizerStyles_unstable = useVirtualizerStyles_unstable;
+//# sourceMappingURL=useVirtualizerStyles.js.map