@king-design/vue 3.5.0-beta.0 → 3.5.1-beta.0

package/components/virtualList/index.spec.js

@@ -0,0 +1,372 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _asyncToGenerator from "@babel/runtime-corejs3/helpers/asyncToGenerator";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import _Array$from from "@babel/runtime-corejs3/core-js/array/from";
+import _filterInstanceProperty from "@babel/runtime-corejs3/core-js/instance/filter";
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/slice";
+import _regeneratorRuntime from "@babel/runtime-corejs3/regenerator";
+import { mount, unmount, getElement, wait } from '../../test/utils';
+import { VirtualList } from './';
+import { Component } from 'intact-vue-next';
+import BasicDemo from '~/components/virtualList/demos/basic';
+import CombinedDemo from '~/components/virtualList/demos/combined';
+describe('VirtualList', function () {
+  afterEach(function () {
+    return unmount();
+  });
+  it('should render virtual list correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+    var _mount, instance, element, container, wrapper, items;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _mount = mount(BasicDemo), instance = _mount[0], element = _mount[1]; // check basic structure
+          container = element.querySelector('.k-virtual-container');
+          expect(container.outerHTML).to.matchSnapshot();
+          wrapper = element.querySelector('.k-virtual-wrapper');
+          expect(wrapper).to.exist;
+          // check render items is less than total
+          items = wrapper.children;
+          expect(items.length).to.be.lessThan(100);
+        case 7:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('should handle scroll correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+    var _mount2, instance, element, container, wrapper, currentFirstItem;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _mount2 = mount(BasicDemo), instance = _mount2[0], element = _mount2[1];
+          container = element.querySelector('.k-virtual-container');
+          wrapper = element.querySelector('.k-virtual-wrapper');
+          _context2.next = 5;
+          return wait(50);
+        case 5:
+          container.scrollTop = 400;
+          _context2.next = 8;
+          return wait(50);
+        case 8:
+          // check content is updated
+          currentFirstItem = wrapper.firstElementChild;
+          expect(currentFirstItem.textContent).to.not.equal('测试0');
+        case 10:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('should update total height when data changes', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
+    var _mount3, instance, element, _element$querySelecto, container2, _element$querySelecto2, phantom2, initialHeight;
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          _mount3 = mount(BasicDemo), instance = _mount3[0], element = _mount3[1];
+          _element$querySelecto = element.querySelectorAll('.k-virtual-container'), container2 = _element$querySelecto[1];
+          _element$querySelecto2 = element.querySelectorAll('.k-virtual-phantom'), phantom2 = _element$querySelecto2[1];
+          initialHeight = phantom2.style.height;
+          _context3.next = 6;
+          return wait(50);
+        case 6:
+          container2.scrollTop = 800;
+          _context3.next = 9;
+          return wait(50);
+        case 9:
+          // check phantom height is updated
+          expect(phantom2.style.height).to.not.equal(initialHeight);
+        case 10:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  it('should work with custom container and wrapper', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+    var _mount4, instance, element, container, wrapper;
+    return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _mount4 = mount(CombinedDemo), instance = _mount4[0], element = _mount4[1];
+          _context4.next = 3;
+          return wait();
+        case 3:
+          container = element.querySelector('.k-virtual-container');
+          wrapper = element.querySelector('.k-virtual-wrapper');
+          expect(container.outerHTML).to.matchSnapshot();
+          // check wrapper tag name
+          expect(wrapper.tagName.toLowerCase()).to.equal('ul');
+        case 7:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  })));
+  it('should handle dynamic data changes correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+    var _context6, _context7;
+    var Demo, _mount5, instance, container, wrapper, middleContent, newList, prevScrollTop;
+    return _regeneratorRuntime.wrap(function _callee5$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          Demo = /*#__PURE__*/function (_Component) {
+            _inheritsLoose(Demo, _Component);
+            function Demo() {
+              var _context5;
+              var _this;
+              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+                args[_key] = arguments[_key];
+              }
+              _this = _Component.call.apply(_Component, _concatInstanceProperty(_context5 = [this]).call(_context5, args)) || this;
+              _this.VirtualList = VirtualList;
+              return _this;
+            }
+            Demo.defaults = function defaults() {
+              return {
+                list: _Array$from({
+                  length: 100
+                }, function (_, i) {
+                  return i;
+                })
+              };
+            };
+            return Demo;
+          }(Component);
+          Demo.template = "\n                const VirtualList = this.VirtualList;\n                <VirtualList style=\"height: 300px\">\n                    <div v-for={this.get('list')} key={$value}>Item {$value}</div>\n                </VirtualList>\n            ";
+          _mount5 = mount(Demo), instance = _mount5[0];
+          _context8.next = 5;
+          return wait();
+        case 5:
+          container = getElement('.k-virtual-container');
+          wrapper = getElement('.k-virtual-wrapper');
+          instance.set('list', _filterInstanceProperty(_context6 = instance.get('list')).call(_context6, function (i) {
+            return i % 2 === 0;
+          }));
+          _context8.next = 10;
+          return wait();
+        case 10:
+          // check deleted render
+          expect(wrapper.children.length).to.be.lessThan(100);
+          expect(wrapper.firstElementChild.textContent).to.equal('Item 0');
+          container.scrollTop = 300;
+          _context8.next = 15;
+          return wait(50);
+        case 15:
+          // check scroll render
+          middleContent = wrapper.firstElementChild.textContent;
+          expect(middleContent).to.not.equal('Item 0');
+          newList = _concatInstanceProperty(_context7 = []).call(_context7, instance.get('list'), _Array$from({
+            length: 20
+          }, function (_, i) {
+            return i + 200;
+          }));
+          instance.set('list', newList);
+          _context8.next = 21;
+          return wait(50);
+        case 21:
+          // check add render position not change
+          expect(wrapper.firstElementChild.textContent).to.equal(middleContent);
+          prevScrollTop = container.scrollTop;
+          container.scrollTop = prevScrollTop + 200;
+          _context8.next = 26;
+          return wait(50);
+        case 26:
+          // check scroll to new content
+          expect(wrapper.firstElementChild.textContent).to.not.equal(middleContent);
+        case 27:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee5);
+  })));
+  it('should handle visible area data changes', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
+    var Demo, _mount6, instance, element, container, wrapper, visibleFirstItem, currentList, visibleIndex, newList;
+    return _regeneratorRuntime.wrap(function _callee6$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          Demo = /*#__PURE__*/function (_Component2) {
+            _inheritsLoose(Demo, _Component2);
+            function Demo() {
+              var _context9;
+              var _this2;
+              for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+                args[_key2] = arguments[_key2];
+              }
+              _this2 = _Component2.call.apply(_Component2, _concatInstanceProperty(_context9 = [this]).call(_context9, args)) || this;
+              _this2.VirtualList = VirtualList;
+              return _this2;
+            }
+            Demo.defaults = function defaults() {
+              return {
+                list: _Array$from({
+                  length: 100
+                }, function (_, i) {
+                  return i;
+                })
+              };
+            };
+            return Demo;
+          }(Component);
+          Demo.template = "\n                const VirtualList = this.VirtualList;\n                <VirtualList style=\"height: 300px\">\n                    <div v-for={this.get('list')} key={$value}>Item {$value}</div>\n                </VirtualList>\n            ";
+          _mount6 = mount(Demo), instance = _mount6[0], element = _mount6[1];
+          _context10.next = 5;
+          return wait();
+        case 5:
+          container = getElement('.k-virtual-container');
+          wrapper = getElement('.k-virtual-wrapper');
+          container.scrollTop = 300;
+          _context10.next = 10;
+          return wait(50);
+        case 10:
+          visibleFirstItem = wrapper.firstElementChild.textContent;
+          currentList = instance.get('list'); // delete visible items
+          visibleIndex = parseInt(visibleFirstItem.replace('Item ', ''));
+          newList = _filterInstanceProperty(currentList).call(currentList, function (i) {
+            return i !== visibleIndex && i !== visibleIndex + 1;
+          });
+          instance.set('list', newList);
+          _context10.next = 17;
+          return wait();
+        case 17:
+          // check deleted render and position
+          expect(wrapper.firstElementChild.textContent).to.not.equal(visibleFirstItem);
+          expect(wrapper.children.length).to.be.greaterThan(0);
+        case 19:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee6);
+  })));
+  it('should clean up height cache when items are deleted', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+    var Demo, _mount7, instance, element, container, wrapper, firstVisibleItem, firstVisibleIndex, currentList, newList, newFirstItem, afterScrollItem;
+    return _regeneratorRuntime.wrap(function _callee7$(_context12) {
+      while (1) switch (_context12.prev = _context12.next) {
+        case 0:
+          Demo = /*#__PURE__*/function (_Component3) {
+            _inheritsLoose(Demo, _Component3);
+            function Demo() {
+              var _context11;
+              var _this3;
+              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
+              }
+              _this3 = _Component3.call.apply(_Component3, _concatInstanceProperty(_context11 = [this]).call(_context11, args)) || this;
+              _this3.VirtualList = VirtualList;
+              return _this3;
+            }
+            Demo.defaults = function defaults() {
+              return {
+                list: _Array$from({
+                  length: 100
+                }, function (_, i) {
+                  return i;
+                })
+              };
+            };
+            return Demo;
+          }(Component);
+          Demo.template = "\n                const VirtualList = this.VirtualList;\n                <VirtualList style=\"height: 300px\">\n                    <div v-for={this.get('list')} key={$value} style=\"height: 30px\">Item {$value}</div>\n                </VirtualList>\n            ";
+          _mount7 = mount(Demo), instance = _mount7[0], element = _mount7[1];
+          _context12.next = 5;
+          return wait();
+        case 5:
+          container = getElement('.k-virtual-container'); // first cache some height
+          container.scrollTop = 300;
+          _context12.next = 9;
+          return wait(50);
+        case 9:
+          // get first visible item
+          wrapper = getElement('.k-virtual-wrapper');
+          firstVisibleItem = wrapper.firstElementChild;
+          firstVisibleIndex = parseInt(firstVisibleItem.textContent.replace('Item ', '')); // delete visible items
+          currentList = instance.get('list');
+          newList = _filterInstanceProperty(currentList).call(currentList, function (i) {
+            return i > firstVisibleIndex + 5;
+          });
+          instance.set('list', newList);
+          _context12.next = 17;
+          return wait(50);
+        case 17:
+          // check scroll position is adjusted
+          newFirstItem = wrapper.firstElementChild;
+          expect(parseInt(newFirstItem.textContent.replace('Item ', ''))).to.be.greaterThan(firstVisibleIndex);
+          // scroll again to check render is normal
+          container.scrollTop += 100;
+          _context12.next = 22;
+          return wait(50);
+        case 22:
+          // check new render position is correct
+          afterScrollItem = wrapper.firstElementChild;
+          expect(afterScrollItem.textContent).to.not.equal(newFirstItem.textContent);
+        case 24:
+        case "end":
+          return _context12.stop();
+      }
+    }, _callee7);
+  })));
+  it('should update total height when deleting last items', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var Demo, _mount8, instance, element, container, phantom, initialHeight, wrapper, lastVisibleItem, lastVisibleIndex, currentList, newList, finalHeight, newLastItem, newLastIndex, containerRect, lastItemRect, isAtBottom;
+    return _regeneratorRuntime.wrap(function _callee8$(_context14) {
+      while (1) switch (_context14.prev = _context14.next) {
+        case 0:
+          Demo = /*#__PURE__*/function (_Component4) {
+            _inheritsLoose(Demo, _Component4);
+            function Demo() {
+              var _context13;
+              var _this4;
+              for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+                args[_key4] = arguments[_key4];
+              }
+              _this4 = _Component4.call.apply(_Component4, _concatInstanceProperty(_context13 = [this]).call(_context13, args)) || this;
+              _this4.VirtualList = VirtualList;
+              return _this4;
+            }
+            Demo.defaults = function defaults() {
+              return {
+                list: _Array$from({
+                  length: 100
+                }, function (_, i) {
+                  return i;
+                })
+              };
+            };
+            return Demo;
+          }(Component);
+          Demo.template = "\n                const VirtualList = this.VirtualList;\n                <VirtualList style=\"height: 300px\">\n                    <div v-for={this.get('list')} key={$value} style=\"height: 30px\">Item {$value}</div>\n                </VirtualList>\n            ";
+          _mount8 = mount(Demo), instance = _mount8[0], element = _mount8[1];
+          _context14.next = 5;
+          return wait();
+        case 5:
+          container = getElement('.k-virtual-container');
+          phantom = getElement('.k-virtual-phantom'); // record initial total height
+          initialHeight = parseInt(phantom.style.height); // scroll to cache height
+          container.scrollTop = initialHeight;
+          _context14.next = 11;
+          return wait(50);
+        case 11:
+          wrapper = getElement('.k-virtual-wrapper');
+          lastVisibleItem = wrapper.lastElementChild;
+          lastVisibleIndex = parseInt(lastVisibleItem.textContent.replace('Item ', '')); // delete last 5 items
+          currentList = instance.get('list');
+          newList = _sliceInstanceProperty(currentList).call(currentList, 0, -5);
+          instance.set('list', newList);
+          _context14.next = 19;
+          return wait(50);
+        case 19:
+          // check total height is updated
+          finalHeight = parseInt(phantom.style.height);
+          expect(finalHeight).to.equal(initialHeight - 5 * 30);
+          // check new last item is at bottom
+          newLastItem = wrapper.lastElementChild;
+          newLastIndex = parseInt(newLastItem.textContent.replace('Item ', ''));
+          expect(newLastIndex).to.equal(94);
+          // check new last item is at bottom
+          containerRect = container.getBoundingClientRect();
+          lastItemRect = newLastItem.getBoundingClientRect();
+          isAtBottom = Math.abs(containerRect.bottom - lastItemRect.bottom) <= 1;
+          expect(isAtBottom).to.be.true;
+        case 28:
+        case "end":
+          return _context14.stop();
+      }
+    }, _callee8);
+  })));
+});

package/components/virtualList/phantom.d.ts

@@ -0,0 +1,9 @@
+import { Component, TypeDefs } from 'intact-vue-next';
+export interface VirtualListPhantomProps {
+    tagName?: string;
+}
+export declare class VirtualListPhantom extends Component<VirtualListPhantomProps> {
+    static template: string | import('intact-vue-next').Template<any>;
+    static typeDefs: Required<TypeDefs<VirtualListPhantomProps>>;
+    private config;
+}

package/components/virtualList/phantom.js

@@ -0,0 +1,24 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { Component } from 'intact-vue-next';
+import template from './phantom.vdt';
+import { useConfigContext } from '../config';
+var typeDefs = {
+  tagName: String
+};
+export var VirtualListPhantom = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(VirtualListPhantom, _Component);
+  function VirtualListPhantom() {
+    var _context;
+    var _this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.config = useConfigContext();
+    return _this;
+  }
+  return VirtualListPhantom;
+}(Component);
+VirtualListPhantom.template = template;
+VirtualListPhantom.typeDefs = typeDefs;

package/components/virtualList/phantom.vdt.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime-corejs3/helpers/extends";
+import { createUnknownComponentVNode as _$cc } from 'intact-vue-next';
+import { getRestProps } from '../utils';
+import { context as VirtualRowsContext } from './useVirtualRows';
+import { cx } from '@emotion/css';
+import { createVNode } from 'intact-vue-next';
+import { makePhantomStyles } from './styles';
+export default function ($props, $blocks, $__proto__) {
+  var _classNameObj,
+    _this = this;
+  $blocks || ($blocks = {});
+  $props || ($props = {});
+  var $this = this;
+  var _this$get = this.get(),
+    className = _this$get.className,
+    tagName = _this$get.tagName;
+  var k = this.config.k;
+  var classNameObj = (_classNameObj = {}, _classNameObj[k + "-virtual-phantom"] = true, _classNameObj[makePhantomStyles()] = true, _classNameObj[className] = className, _classNameObj);
+  return _$cc(VirtualRowsContext.Consumer, {
+    'children': function children(_ref) {
+      var getTotalHeight = _ref.getTotalHeight,
+        disabled = _ref.disabled;
+      if (disabled) return;
+      return createVNode(tagName || 'div', _extends({}, getRestProps(_this), {
+        className: cx(classNameObj),
+        style: {
+          height: getTotalHeight() + 'px'
+        }
+      }));
+    }
+  });
+}
+;

package/components/virtualList/rows.d.ts

@@ -0,0 +1,8 @@
+import { Component } from 'intact-vue-next';
+export interface VirtualListRowsProps {
+    tagName?: string;
+}
+export declare class VirtualListRows extends Component<VirtualListRowsProps> {
+    static template: string | import('intact-vue-next').Template<any>;
+    private rows;
+}

package/components/virtualList/rows.js

@@ -0,0 +1,20 @@
+import _inheritsLoose from "@babel/runtime-corejs3/helpers/inheritsLoose";
+import _concatInstanceProperty from "@babel/runtime-corejs3/core-js/instance/concat";
+import { Component } from 'intact-vue-next';
+import { useRows } from './useRows';
+import template from './rows.vdt';
+export var VirtualListRows = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(VirtualListRows, _Component);
+  function VirtualListRows() {
+    var _context;
+    var _this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _Component.call.apply(_Component, _concatInstanceProperty(_context = [this]).call(_context, args)) || this;
+    _this.rows = useRows();
+    return _this;
+  }
+  return VirtualListRows;
+}(Component);
+VirtualListRows.template = template;

package/components/virtualList/rows.vdt.js

@@ -0,0 +1,32 @@
+import _sliceInstanceProperty from "@babel/runtime-corejs3/core-js/instance/slice";
+import { createUnknownComponentVNode as _$cc } from 'intact-vue-next';
+import { createFragment, createVNode } from 'intact-vue-next';
+import { isNullOrUndefined } from 'intact-shared';
+import { context as VirtualRowsContext } from './useVirtualRows';
+export default function ($props, $blocks, $__proto__) {
+  $blocks || ($blocks = {});
+  $props || ($props = {});
+  var $this = this;
+  var _this$get = this.get(),
+    tagName = _this$get.tagName,
+    _children = _this$get.children;
+  var rows = this.rows;
+  return _$cc(VirtualRowsContext.Consumer, {
+    'children': function children(_ref) {
+      var notifyRows = _ref.notifyRows,
+        startIndex = _ref.startIndex,
+        length = _ref.length,
+        disabled = _ref.disabled;
+      if (!disabled) {
+        var _context;
+        _children = _sliceInstanceProperty(_context = rows.value).call(_context, startIndex, startIndex + length);
+        notifyRows(rows.value);
+      }
+      if (isNullOrUndefined(tagName)) {
+        return createFragment(_children, 8 /* ChildrenTypes.HasKeyedChildren */);
+      }
+      return createVNode(tagName, null, _children);
+    }
+  });
+}
+;

package/components/virtualList/styles.d.ts

@@ -0,0 +1,13 @@
+import '../../styles/global';
+export declare const makeContainerStyles: {
+    (): string;
+    clearCache(): {};
+};
+export declare const makePhantomStyles: {
+    (): string;
+    clearCache(): {};
+};
+export declare const makeWrapperStyles: {
+    (): string;
+    clearCache(): {};
+};

package/components/virtualList/styles.js

@@ -0,0 +1,34 @@
+function _EMOTION_STRINGIFIED_CSS_ERROR__() { return "You have tried to stringify object returned from `css` function. It isn't supposed to be used directly (e.g. as value of the `className` prop), but rather handed to emotion so it can handle it (e.g. as value of `css` prop)."; }
+import { css } from '@emotion/css';
+import '../../styles/global';
+import { cache } from '../utils';
+export var makeContainerStyles = cache(function () {
+  return /*#__PURE__*/css(process.env.NODE_ENV === "production" ? {
+    name: "1mtyfo1",
+    styles: "overflow:auto;position:relative;height:100%"
+  } : {
+    name: "1mtyfo1",
+    styles: "overflow:auto;position:relative;height:100%",
+    toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+  });
+});
+export var makePhantomStyles = cache(function () {
+  return /*#__PURE__*/css(process.env.NODE_ENV === "production" ? {
+    name: "aekvjh",
+    styles: "position:absolute;left:0;top:0;right:0;z-index:-1;pointer-events:none"
+  } : {
+    name: "aekvjh",
+    styles: "position:absolute;left:0;top:0;right:0;z-index:-1;pointer-events:none",
+    toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+  });
+});
+export var makeWrapperStyles = cache(function () {
+  return /*#__PURE__*/css(process.env.NODE_ENV === "production" ? {
+    name: "1hssyz7",
+    styles: "width:100%;will-change:transform"
+  } : {
+    name: "1hssyz7",
+    styles: "width:100%;will-change:transform",
+    toString: _EMOTION_STRINGIFIED_CSS_ERROR__
+  });
+});

package/components/virtualList/useRows.d.ts

@@ -0,0 +1,2 @@
+import { VNode } from 'intact-vue-next';
+export declare function useRows(): import('intact-vue-next').NonNullableRefObject<VNode<import('intact-vue-next').VNodeTag>[]>;

package/components/virtualList/useRows.js

@@ -0,0 +1,19 @@
+import { useInstance, createRef, createFragment } from 'intact-vue-next';
+export function useRows() {
+  var instance = useInstance();
+  var rows = createRef([]);
+  instance.on('$receive:children', function (children) {
+    // use fragment vnode to normalize children
+    var vNode = createFragment(children, 0 /* ChildrenTypes.UnknownChildren */);
+    // convert to array if it has only one child
+    var childrenType = vNode.childrenType;
+    if (childrenType & 2 /* ChildrenTypes.HasVNodeChildren */) {
+      rows.value = [vNode.children];
+    } else if (childrenType & 1 /* ChildrenTypes.HasInvalidChildren */) {
+      rows.value = [];
+    } else {
+      rows.value = vNode.children;
+    }
+  });
+  return rows;
+}

package/components/virtualList/useVirtualRows.d.ts

@@ -0,0 +1,20 @@
+import { State } from '../../hooks/useState';
+import { VNode } from 'intact-vue-next';
+type ContextValue = {
+    notifyRows: (rows: State<VNode[]>) => void;
+    startIndex: number;
+    endIndex: number;
+};
+export declare const context: {
+    Provider: import('intact-vue-next').ComponentConstructor<import('intact-vue-next').Component<import("../context").ProviderProps<ContextValue>, {}, {}, {}>>;
+    Consumer: import('intact-vue-next').ComponentConstructor<import('intact-vue-next').Component<import("../context").ConsumerProps<ContextValue>, {}, {}, {}>>;
+    useContext: () => import('intact-vue-next').RefObject<ContextValue | undefined>;
+};
+export declare function useVirtualRows(): {
+    notifyRows: (_rows: VNode[]) => void;
+    startIndex: State<number>;
+    length: State<number>;
+    getTotalHeight: () => number;
+    translateY: State<number>;
+};
+export {};