@tanstack/react-table 0.0.1-alpha.9 → 8.0.0-alpha.14

package/build/stats-react.json

@@ -0,0 +1,99 @@
+{
+  "version": 2,
+  "tree": {
+    "name": "root",
+    "children": [
+      {
+        "name": "index.production.js",
+        "children": [
+          {
+            "uid": "6958-111",
+            "name": "\u0000rollupPluginBabelHelpers.js"
+          },
+          {
+            "name": "packages/react-table/src/index.tsx",
+            "uid": "6958-113"
+          }
+        ]
+      }
+    ],
+    "isRoot": true
+  },
+  "nodeParts": {
+    "6958-111": {
+      "renderedLength": 410,
+      "gzipLength": 231,
+      "brotliLength": 0,
+      "mainUid": "6958-110"
+    },
+    "6958-113": {
+      "renderedLength": 2378,
+      "gzipLength": 855,
+      "brotliLength": 0,
+      "mainUid": "6958-112"
+    }
+  },
+  "nodeMetas": {
+    "6958-110": {
+      "id": "\u0000rollupPluginBabelHelpers.js",
+      "moduleParts": {
+        "index.production.js": "6958-111"
+      },
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "6958-112"
+        }
+      ]
+    },
+    "6958-112": {
+      "id": "/packages/react-table/src/index.tsx",
+      "moduleParts": {
+        "index.production.js": "6958-113"
+      },
+      "imported": [
+        {
+          "uid": "6958-110"
+        },
+        {
+          "uid": "6958-114"
+        },
+        {
+          "uid": "6958-115"
+        }
+      ],
+      "importedBy": [],
+      "isEntry": true
+    },
+    "6958-114": {
+      "id": "react",
+      "moduleParts": {},
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "6958-112"
+        }
+      ],
+      "isExternal": true
+    },
+    "6958-115": {
+      "id": "@tanstack/table-core",
+      "moduleParts": {},
+      "imported": [],
+      "importedBy": [
+        {
+          "uid": "6958-112"
+        }
+      ],
+      "isExternal": true
+    }
+  },
+  "env": {
+    "rollup": "2.66.0"
+  },
+  "options": {
+    "gzip": true,
+    "brotli": false,
+    "sourcemap": false
+  }
+}

package/build/types/index.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+export * from '@tanstack/table-core';
+import { PartialKeys, Options, TableInstance, CreateTableFactoryOptions, Table, AnyGenerics } from '@tanstack/table-core';
+export declare type Renderable<TProps> = React.ReactNode | React.FunctionComponent<TProps> | React.Component<TProps>;
+export declare const render: <TProps extends {}>(Comp: Renderable<TProps>, props: TProps) => React.ReactNode;
+export declare type Render = typeof render;
+declare const createTable: import("@tanstack/table-core").CreateTableFactory<import("@tanstack/table-core").Overwrite<Partial<import("@tanstack/table-core").DefaultGenerics>, {
+    Render: <TProps extends {}>(Comp: Renderable<TProps>, props: TProps) => React.ReactNode;
+}>>, createTableFactory: <TGenerics extends Partial<import("@tanstack/table-core").DefaultGenerics>>(options?: CreateTableFactoryOptions<(<TProps extends {}>(Comp: Renderable<TProps>, props: TProps) => React.ReactNode), any, any, any> | undefined) => import("@tanstack/table-core").CreateTableFactory<import("@tanstack/table-core").Overwrite<TGenerics, {
+    Render: <TProps extends {}>(Comp: Renderable<TProps>, props: TProps) => React.ReactNode;
+}>>;
+export { createTable, createTableFactory };
+export declare function useTable<TGenerics extends AnyGenerics>(table: Table<TGenerics>, options: PartialKeys<Omit<Options<TGenerics>, keyof CreateTableFactoryOptions<any, any, any, any>>, 'state' | 'onStateChange'>): TableInstance<TGenerics>;

package/build/umd/index.development.js

@@ -0,0 +1,134 @@
+/**
+ * react-table
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react'), require('@tanstack/table-core')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', '@tanstack/table-core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactTable = {}, global.React, global.TableCore));
+})(this, (function (exports, React, tableCore) { 'use strict';
+
+  function _interopNamespace(e) {
+    if (e && e.__esModule) return e;
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+  }
+
+  var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
+  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);
+  }
+
+  var render = function render(Comp, props) {
+    return !Comp ? null : isReactComponent(Comp) ? /*#__PURE__*/React__namespace.createElement(Comp, props) : Comp;
+  };
+
+  function isReactComponent(component) {
+    return isClassComponent(component) || typeof component === 'function' || isExoticComponent(component);
+  }
+
+  function isClassComponent(component) {
+    return typeof component === 'function' && function () {
+      var proto = Object.getPrototypeOf(component);
+      return proto.prototype && proto.prototype.isReactComponent;
+    }();
+  }
+
+  function isExoticComponent(component) {
+    return typeof component === 'object' && typeof component.$$typeof === 'symbol' && ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description);
+  }
+
+  var _init = tableCore.init({
+    render: render
+  }),
+      createTable = _init.createTable,
+      createTableFactory = _init.createTableFactory;
+  function useTable(table, options) {
+    var _table$__options;
+
+    // Compose in the generic options to the user options
+    var resolvedOptions = _extends({}, (_table$__options = table.__options) != null ? _table$__options : {}, {
+      state: {},
+      // Dummy state
+      onStateChange: function onStateChange() {},
+      // noop
+      render: render
+    }, options); // Create a new table instance and store it in state
+
+
+    var _React$useState = React__namespace.useState(function () {
+      return tableCore.createTableInstance(resolvedOptions);
+    }),
+        instance = _React$useState[0]; // By default, manage table state here using the instance's initial state
+
+
+    var _React$useState2 = React__namespace.useState(function () {
+      return instance.initialState;
+    }),
+        state = _React$useState2[0],
+        setState = _React$useState2[1]; // Compose the default state above with any user state. This will allow the user
+    // to only control a subset of the state if desired.
+
+
+    instance.setOptions(function (prev) {
+      return _extends({}, prev, options, {
+        state: _extends({}, state, options.state),
+        // Similarly, we'll maintain both our internal state and any user-provided
+        // state.
+        onStateChange: function onStateChange(updater) {
+          setState(updater);
+          options.onStateChange == null ? void 0 : options.onStateChange(updater);
+        }
+      });
+    });
+    return instance;
+  }
+
+  exports.createTable = createTable;
+  exports.createTableFactory = createTableFactory;
+  exports.render = render;
+  exports.useTable = useTable;
+  Object.keys(tableCore).forEach(function (k) {
+    if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+      enumerable: true,
+      get: function () { return tableCore[k]; }
+    });
+  });
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.development.js.map

package/build/umd/index.development.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.development.js","sources":["../../src/index.tsx"],"sourcesContent":["import * as React from 'react'\nexport * from '@tanstack/table-core'\n\nimport {\n  createTableInstance,\n  _NonGenerated,\n  PartialKeys,\n  Options,\n  TableInstance,\n  PartialGenerics,\n  CreateTableFactoryOptions,\n  Table,\n  init,\n  AnyGenerics,\n} from '@tanstack/table-core'\n\nexport type Renderable<TProps> =\n  | React.ReactNode\n  | React.FunctionComponent<TProps>\n  | React.Component<TProps>\n\nexport const render = <TProps extends {}>(\n  Comp: Renderable<TProps>,\n  props: TProps\n): React.ReactNode =>\n  !Comp ? null : isReactComponent(Comp) ? <Comp {...props} /> : Comp\n\nexport type Render = typeof render\n\nfunction isReactComponent(component: unknown): component is React.FC {\n  return (\n    isClassComponent(component) ||\n    typeof component === 'function' ||\n    isExoticComponent(component)\n  )\n}\n\nfunction isClassComponent(component: any) {\n  return (\n    typeof component === 'function' &&\n    (() => {\n      const proto = Object.getPrototypeOf(component)\n      return proto.prototype && proto.prototype.isReactComponent\n    })()\n  )\n}\n\nfunction isExoticComponent(component: any) {\n  return (\n    typeof component === 'object' &&\n    typeof component.$$typeof === 'symbol' &&\n    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)\n  )\n}\n\nconst { createTable, createTableFactory } = init({ render })\n\nexport { createTable, createTableFactory }\n\nexport function useTable<TGenerics extends AnyGenerics>(\n  table: Table<TGenerics>,\n  options: PartialKeys<\n    Omit<\n      Options<TGenerics>,\n      keyof CreateTableFactoryOptions<any, any, any, any>\n    >,\n    'state' | 'onStateChange'\n  >\n): TableInstance<TGenerics> {\n  // Compose in the generic options to the user options\n  const resolvedOptions: Options<TGenerics> = {\n    ...(table.__options ?? {}),\n    state: {}, // Dummy state\n    onStateChange: () => {}, // noop\n    render,\n    ...options,\n  }\n\n  // Create a new table instance and store it in state\n  const [instance] = React.useState(() =>\n    createTableInstance<TGenerics>(resolvedOptions)\n  )\n\n  // By default, manage table state here using the instance's initial state\n  const [state, setState] = React.useState(() => instance.initialState)\n\n  // Compose the default state above with any user state. This will allow the user\n  // to only control a subset of the state if desired.\n  instance.setOptions(prev => ({\n    ...prev,\n    ...options,\n    state: {\n      ...state,\n      ...options.state,\n    },\n    // Similarly, we'll maintain both our internal state and any user-provided\n    // state.\n    onStateChange: updater => {\n      setState(updater)\n      options.onStateChange?.(updater)\n    },\n  }))\n\n  return instance\n}\n"],"names":["render","Comp","props","isReactComponent","React","component","isClassComponent","isExoticComponent","proto","Object","getPrototypeOf","prototype","$$typeof","includes","description","init","createTable","createTableFactory","useTable","table","options","resolvedOptions","__options","state","onStateChange","useState","createTableInstance","instance","initialState","setState","setOptions","prev","updater"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAqBaA,MAAM,GAAG,SAATA,MAAS,CACpBC,IADoB,EAEpBC,KAFoB;EAAA,SAIpB,CAACD,IAAD,GAAQ,IAAR,GAAeE,gBAAgB,CAACF,IAAD,CAAhB,gBAAyBG,+BAAC,IAAD,EAAUF,KAAV,CAAzB,GAA+CD,IAJ1C;EAAA;;EAQtB,SAASE,gBAAT,CAA0BE,SAA1B,EAAqE;EACnE,SACEC,gBAAgB,CAACD,SAAD,CAAhB,IACA,OAAOA,SAAP,KAAqB,UADrB,IAEAE,iBAAiB,CAACF,SAAD,CAHnB;EAKD;;EAED,SAASC,gBAAT,CAA0BD,SAA1B,EAA0C;EACxC,SACE,OAAOA,SAAP,KAAqB,UAArB,IACC,YAAM;EACL,QAAMG,KAAK,GAAGC,MAAM,CAACC,cAAP,CAAsBL,SAAtB,CAAd;EACA,WAAOG,KAAK,CAACG,SAAN,IAAmBH,KAAK,CAACG,SAAN,CAAgBR,gBAA1C;EACD,GAHD,EAFF;EAOD;;EAED,SAASI,iBAAT,CAA2BF,SAA3B,EAA2C;EACzC,SACE,OAAOA,SAAP,KAAqB,QAArB,IACA,OAAOA,SAAS,CAACO,QAAjB,KAA8B,QAD9B,IAEA,CAAC,YAAD,EAAe,mBAAf,EAAoCC,QAApC,CAA6CR,SAAS,CAACO,QAAV,CAAmBE,WAAhE,CAHF;EAKD;;cAE2CC,cAAI,CAAC;EAAEf,EAAAA,MAAM,EAANA;EAAF,CAAD,CAAhD;EAAA,IAAQgB,WAAR,SAAQA,WAAR;EAAA,IAAqBC,kBAArB,SAAqBA;EAId,SAASC,QAAT,CACLC,KADK,EAELC,OAFK,EASqB;EAAA;;EAC1B;EACA,MAAMC,eAAmC,oCACnCF,KAAK,CAACG,SAD6B,+BAChB,EADgB;EAEvCC,IAAAA,KAAK,EAAE,EAFgC;EAE5B;EACXC,IAAAA,aAAa,EAAE,yBAAM,EAHkB;EAGd;EACzBxB,IAAAA,MAAM,EAANA;EAJuC,KAKpCoB,OALoC,CAAzC,CAF0B;;;EAW1B,wBAAmBhB,gBAAK,CAACqB,QAAN,CAAe;EAAA,WAChCC,6BAAmB,CAAYL,eAAZ,CADa;EAAA,GAAf,CAAnB;EAAA,MAAOM,QAAP,sBAX0B;;;EAgB1B,yBAA0BvB,gBAAK,CAACqB,QAAN,CAAe;EAAA,WAAME,QAAQ,CAACC,YAAf;EAAA,GAAf,CAA1B;EAAA,MAAOL,KAAP;EAAA,MAAcM,QAAd,uBAhB0B;EAmB1B;;;EACAF,EAAAA,QAAQ,CAACG,UAAT,CAAoB,UAAAC,IAAI;EAAA,wBACnBA,IADmB,EAEnBX,OAFmB;EAGtBG,MAAAA,KAAK,eACAA,KADA,EAEAH,OAAO,CAACG,KAFR,CAHiB;EAOtB;EACA;EACAC,MAAAA,aAAa,EAAE,uBAAAQ,OAAO,EAAI;EACxBH,QAAAA,QAAQ,CAACG,OAAD,CAAR;EACAZ,QAAAA,OAAO,CAACI,aAAR,oBAAAJ,OAAO,CAACI,aAAR,CAAwBQ,OAAxB;EACD;EAZqB;EAAA,GAAxB;EAeA,SAAOL,QAAP;EACD;;;;;;;;;;;;;;;;;;;"}

package/build/umd/index.production.js

@@ -0,0 +1,12 @@
+/**
+ * react-table
+ *
+ * Copyright (c) TanStack
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE.md file in the root directory of this source tree.
+ *
+ * @license MIT
+ */
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react"),require("@tanstack/table-core")):"function"==typeof define&&define.amd?define(["exports","react","@tanstack/table-core"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).ReactTable={},e.React,e.TableCore)}(this,(function(e,t,n){"use strict";function r(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(n){if("default"!==n){var r=Object.getOwnPropertyDescriptor(e,n);Object.defineProperty(t,n,r.get?r:{enumerable:!0,get:function(){return e[n]}})}})),t.default=e,Object.freeze(t)}var o=r(t);function a(){return a=Object.assign||function(e){for(var t=1;t<arguments.length;t++){var n=arguments[t];for(var r in n)Object.prototype.hasOwnProperty.call(n,r)&&(e[r]=n[r])}return e},a.apply(this,arguments)}var c=function(e,t){return e?function(e){return"function"==typeof e&&((t=Object.getPrototypeOf(e)).prototype&&t.prototype.isReactComponent);var t}(n=e)||"function"==typeof n||function(e){return"object"==typeof e&&"symbol"==typeof e.$$typeof&&["react.memo","react.forward_ref"].includes(e.$$typeof.description)}(n)?o.createElement(e,t):e:null;var n};var u=n.init({render:c}),f=u.createTable,i=u.createTableFactory;e.createTable=f,e.createTableFactory=i,e.render=c,e.useTable=function(e,t){var r,u=a({},null!=(r=e.__options)?r:{},{state:{},onStateChange:function(){},render:c},t),f=o.useState((function(){return n.createTableInstance(u)}))[0],i=o.useState((function(){return f.initialState})),l=i[0],s=i[1];return f.setOptions((function(e){return a({},e,t,{state:a({},l,t.state),onStateChange:function(e){s(e),null==t.onStateChange||t.onStateChange(e)}})})),f},Object.keys(n).forEach((function(t){"default"===t||e.hasOwnProperty(t)||Object.defineProperty(e,t,{enumerable:!0,get:function(){return n[t]}})})),Object.defineProperty(e,"__esModule",{value:!0})}));
+//# sourceMappingURL=index.production.js.map

package/build/umd/index.production.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.production.js","sources":["../../src/index.tsx"],"sourcesContent":["import * as React from 'react'\nexport * from '@tanstack/table-core'\n\nimport {\n  createTableInstance,\n  _NonGenerated,\n  PartialKeys,\n  Options,\n  TableInstance,\n  PartialGenerics,\n  CreateTableFactoryOptions,\n  Table,\n  init,\n  AnyGenerics,\n} from '@tanstack/table-core'\n\nexport type Renderable<TProps> =\n  | React.ReactNode\n  | React.FunctionComponent<TProps>\n  | React.Component<TProps>\n\nexport const render = <TProps extends {}>(\n  Comp: Renderable<TProps>,\n  props: TProps\n): React.ReactNode =>\n  !Comp ? null : isReactComponent(Comp) ? <Comp {...props} /> : Comp\n\nexport type Render = typeof render\n\nfunction isReactComponent(component: unknown): component is React.FC {\n  return (\n    isClassComponent(component) ||\n    typeof component === 'function' ||\n    isExoticComponent(component)\n  )\n}\n\nfunction isClassComponent(component: any) {\n  return (\n    typeof component === 'function' &&\n    (() => {\n      const proto = Object.getPrototypeOf(component)\n      return proto.prototype && proto.prototype.isReactComponent\n    })()\n  )\n}\n\nfunction isExoticComponent(component: any) {\n  return (\n    typeof component === 'object' &&\n    typeof component.$$typeof === 'symbol' &&\n    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)\n  )\n}\n\nconst { createTable, createTableFactory } = init({ render })\n\nexport { createTable, createTableFactory }\n\nexport function useTable<TGenerics extends AnyGenerics>(\n  table: Table<TGenerics>,\n  options: PartialKeys<\n    Omit<\n      Options<TGenerics>,\n      keyof CreateTableFactoryOptions<any, any, any, any>\n    >,\n    'state' | 'onStateChange'\n  >\n): TableInstance<TGenerics> {\n  // Compose in the generic options to the user options\n  const resolvedOptions: Options<TGenerics> = {\n    ...(table.__options ?? {}),\n    state: {}, // Dummy state\n    onStateChange: () => {}, // noop\n    render,\n    ...options,\n  }\n\n  // Create a new table instance and store it in state\n  const [instance] = React.useState(() =>\n    createTableInstance<TGenerics>(resolvedOptions)\n  )\n\n  // By default, manage table state here using the instance's initial state\n  const [state, setState] = React.useState(() => instance.initialState)\n\n  // Compose the default state above with any user state. This will allow the user\n  // to only control a subset of the state if desired.\n  instance.setOptions(prev => ({\n    ...prev,\n    ...options,\n    state: {\n      ...state,\n      ...options.state,\n    },\n    // Similarly, we'll maintain both our internal state and any user-provided\n    // state.\n    onStateChange: updater => {\n      setState(updater)\n      options.onStateChange?.(updater)\n    },\n  }))\n\n  return instance\n}\n"],"names":["render","Comp","props","component","proto","Object","getPrototypeOf","prototype","isReactComponent","isClassComponent","$$typeof","includes","description","isExoticComponent","React","init","createTable","createTableFactory","table","options","resolvedOptions","__options","state","onStateChange","instance","useState","createTableInstance","initialState","setState","setOptions","prev","updater"],"mappings":";;;;;;;;;;w1BAqBaA,EAAS,SACpBC,EACAC,UAECD,EAYH,SAA0BE,SAED,mBAAdA,KAECC,EAAQC,OAAOC,eAAeH,IACvBI,WAAaH,EAAMG,UAAUC,kBAF3C,IACOJ,EAVRK,CAFsBN,EAJQF,IAOT,mBAAdE,GAeX,SAA2BA,SAEF,iBAAdA,GACuB,iBAAvBA,EAAUO,UACjB,CAAC,aAAc,qBAAqBC,SAASR,EAAUO,SAASE,aAlBhEC,CAAkBV,GARoBW,gBAACb,EAASC,GAAYD,EAAtD,KAIV,IAA0BE,SA0BkBY,OAAK,CAAEf,OAAAA,IAA3CgB,IAAAA,YAAaC,IAAAA,gFAId,SACLC,EACAC,SASMC,gBACAF,EAAMG,aAAa,IACvBC,MAAO,GACPC,cAAe,aACfvB,OAAAA,GACGmB,GAIEK,EAAYV,EAAMW,UAAS,kBAChCC,sBAA+BN,WAIPN,EAAMW,UAAS,kBAAMD,EAASG,gBAAjDL,OAAOM,cAIdJ,EAASK,YAAW,SAAAC,eACfA,EACAX,GACHG,WACKA,EACAH,EAAQG,OAIbC,cAAe,SAAAQ,GACbH,EAASG,SACTZ,EAAQI,eAARJ,EAAQI,cAAgBQ,SAIrBP"}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@tanstack/react-table",
-  "version": "0.0.1-alpha.9",
+  "author": "Tanner Linsley",
+  "version": "8.0.0-alpha.14",
   "description": "Hooks for building lightweight, fast and extendable datagrids for React",
   "license": "MIT",
-  "homepage": "https://github.com/tannerlinsley/react-table#readme",
+  "homepage": "https://github.com/tanstack/react-table#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tannerlinsley/react-table.git"
+    "url": "git+https://github.com/tanstack/react-table.git"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -21,105 +22,22 @@
     "type": "github",
     "url": "https://github.com/sponsors/tannerlinsley"
   },
-  "main": "lib/index.js",
-  "module": "es/index.js",
-  "typings": "types/index.d.ts",
-  "scripts": {
-    "test": "(is-ci && yarn test:ci) || yarn test:dev",
-    "test:dev": "jest --watch",
-    "test:ci": "jest",
-    "test:coverage": "yarn test:ci; open coverage/lcov-report/index.html",
-    "build": "yarn format && yarn build:commonjs && yarn build:es && yarn build:umd && yarn build:types",
-    "build:commonjs": "rimraf ./lib && cross-env BABEL_ENV=commonjs babel --extensions .ts,.tsx --ignore ./src/**/tests/**/* ./src --out-dir lib",
-    "build:es": "rimraf ./es && babel --extensions .ts,.tsx --ignore ./src/**/tests/**/* ./src --out-dir es",
-    "build:umd": "rimraf ./dist && cross-env NODE_ENV=production rollup -c && rollup-plugin-visualizer stats-react.json",
-    "build:types": "rimraf ./types && tsc --project ./tsconfig.types.json && replace 'import type' 'import' ./types -r --silent && replace 'export type' 'export' ./types -r --silent",
-    "watch": "yarn watch:commonjs & yarn watch:es & yarn watch:umd & yarn watch:types",
-    "watch:commonjs": "rimraf ./lib && cross-env BABEL_ENV=commonjs babel --watch --extensions .ts,.tsx --ignore ./src/**/tests/**/* ./src --out-dir lib",
-    "watch:es": "rimraf ./es && babel --watch --extensions .ts,.tsx --ignore ./src/**/tests/**/* ./src --out-dir es",
-    "watch:umd": "rimraf ./dist && cross-env NODE_ENV=production rollup -w -c && rollup-plugin-visualizer stats-react.json",
-    "watch:types": "rimraf ./types && tsc --watch --project ./tsconfig.types.json && replace 'import type' 'import' ./types -r --silent && replace 'export type' 'export' ./types -r --silent",
-    "now-build": "yarn && cd www && yarn && yarn build",
-    "prettier": "prettier \"{.,src,src/**,example/src,example/src/**}/*.{md,js,jsx,ts,tsx,json}\"",
-    "start": "yarn watch",
-    "format": "yarn prettier --write",
-    "stats": "open ./stats.html",
-    "doctoc": "doctoc README.md"
-  },
+  "module": "build/esm/index.js",
+  "main": "build/cjs/index.js",
+  "browser": "build/umd/index.production.min.js",
+  "types": "build/types/index.d.ts",
   "engines": {
     "node": ">=12"
   },
-  "release": {
-    "branches": [
-      "master",
-      {
-        "name": "beta",
-        "prerelease": true
-      }
-    ]
-  },
   "files": [
-    "dist",
+    "build",
     "src"
   ],
-  "browserslist": [
-    "last 2 versions",
-    "> 0.2%"
-  ],
+  "dependencies": {
+    "@tanstack/table-core": "^8.0.0-alpha.9"
+  },
   "peerDependencies": {
     "react": ">=16",
     "react-dom": ">=16"
-  },
-  "dependencies": {
-    "ts-toolbelt": "^9.6.0"
-  },
-  "devDependencies": {
-    "@babel/cli": "^7.15.7",
-    "@babel/core": "^7.15.8",
-    "@babel/plugin-transform-runtime": "^7.15.8",
-    "@babel/preset-env": "^7.15.8",
-    "@babel/preset-react": "^7.14.5",
-    "@babel/preset-typescript": "^7.15.0",
-    "@rollup/plugin-replace": "^3.0.0",
-    "@testing-library/jest-dom": "^5.14.1",
-    "@testing-library/react": "^12.1.2",
-    "@testing-library/react-hooks": "^7.0.2",
-    "@types/react": "^17.0.27",
-    "@types/react-dom": "^17.0.9",
-    "@types/semver": "^7.3.9",
-    "babel-plugin-const-enum": "^1.1.0",
-    "babel-plugin-dev-expression": "^0.2.2",
-    "babel-plugin-transform-async-to-promises": "^0.8.15",
-    "conventional-changelog-angular": "^5.0.13",
-    "cross-env": "^7.0.3",
-    "current-git-branch": "^1.1.0",
-    "doctoc": "^2.1.0",
-    "fast-async": "^6.3.8",
-    "git-log-parser": "^1.2.0",
-    "is-ci": "^3.0.0",
-    "jest": "^27.4.5",
-    "jsonfile": "^6.1.0",
-    "lerna": "^4.0.0",
-    "prettier": "^2.4.1",
-    "prompt-confirm": "^2.0.4",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "react-test-renderer": "^17.0.2",
-    "replace": "^1.2.1",
-    "rimraf": "^3.0.2",
-    "rollup": "^2.16.1",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-commonjs": "^10.1.0",
-    "rollup-plugin-jscc": "^1.0.0",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-peer-deps-external": "^2.2.2",
-    "rollup-plugin-prettier": "^2.1.0",
-    "rollup-plugin-size": "^0.2.2",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-visualizer": "^5.5.2",
-    "stream-to-array": "^2.3.0",
-    "ts-node": "^10.3.0",
-    "tslib": "^2.3.1",
-    "typescript": "^4.4.3"
   }
 }

package/src/index.tsx

@@ -1,7 +1,105 @@
-export * from './types'
-export * from './utils/columnFilterRowsFn'
-export * from './utils/globalFilterRowsFn'
-export * from './utils/sortRowsFn'
-export * from './utils/groupRowsFn'
-export * from './utils/expandRowsFn'
-export { createTable } from './createTable'
+import * as React from 'react'
+export * from '@tanstack/table-core'
+
+import {
+  createTableInstance,
+  _NonGenerated,
+  PartialKeys,
+  Options,
+  TableInstance,
+  PartialGenerics,
+  CreateTableFactoryOptions,
+  Table,
+  init,
+  AnyGenerics,
+} from '@tanstack/table-core'
+
+export type Renderable<TProps> =
+  | React.ReactNode
+  | React.FunctionComponent<TProps>
+  | React.Component<TProps>
+
+export const render = <TProps extends {}>(
+  Comp: Renderable<TProps>,
+  props: TProps
+): React.ReactNode =>
+  !Comp ? null : isReactComponent(Comp) ? <Comp {...props} /> : Comp
+
+export type Render = typeof render
+
+function isReactComponent(component: unknown): component is React.FC {
+  return (
+    isClassComponent(component) ||
+    typeof component === 'function' ||
+    isExoticComponent(component)
+  )
+}
+
+function isClassComponent(component: any) {
+  return (
+    typeof component === 'function' &&
+    (() => {
+      const proto = Object.getPrototypeOf(component)
+      return proto.prototype && proto.prototype.isReactComponent
+    })()
+  )
+}
+
+function isExoticComponent(component: any) {
+  return (
+    typeof component === 'object' &&
+    typeof component.$$typeof === 'symbol' &&
+    ['react.memo', 'react.forward_ref'].includes(component.$$typeof.description)
+  )
+}
+
+const { createTable, createTableFactory } = init({ render })
+
+export { createTable, createTableFactory }
+
+export function useTable<TGenerics extends AnyGenerics>(
+  table: Table<TGenerics>,
+  options: PartialKeys<
+    Omit<
+      Options<TGenerics>,
+      keyof CreateTableFactoryOptions<any, any, any, any>
+    >,
+    'state' | 'onStateChange'
+  >
+): TableInstance<TGenerics> {
+  // Compose in the generic options to the user options
+  const resolvedOptions: Options<TGenerics> = {
+    ...(table.__options ?? {}),
+    state: {}, // Dummy state
+    onStateChange: () => {}, // noop
+    render,
+    ...options,
+  }
+
+  // Create a new table instance and store it in state
+  const [instance] = React.useState(() =>
+    createTableInstance<TGenerics>(resolvedOptions)
+  )
+
+  // By default, manage table state here using the instance's initial state
+  const [state, setState] = React.useState(() => instance.initialState)
+
+  // Compose the default state above with any user state. This will allow the user
+  // to only control a subset of the state if desired.
+  instance.setOptions(prev => ({
+    ...prev,
+    ...options,
+    state: {
+      ...state,
+      ...options.state,
+    },
+    // Similarly, we'll maintain both our internal state and any user-provided
+    // state.
+    onStateChange: updater => {
+      setState(updater)
+      options.onStateChange?.(updater)
+    },
+  }))
+
+  return instance
+}