@azrico/reactgrid 1.0.2 → 1.0.3

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src';
+import { AzGrid } from './src';
+export default AzGrid;

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _src = require("./src");
+Object.keys(_src).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _src[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _src[key];
+    }
+  });
+});
+var _default = _src.AzGrid;
+exports.default = _default;

package/dist/src/example.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+export * from './views/DataGrid';
+export declare function ExampleGrid(): JSX.Element;
+export default ExampleGrid;

package/dist/src/example.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  ExampleGrid: true
+};
+exports.ExampleGrid = ExampleGrid;
+exports.default = void 0;
+var _DataGrid = _interopRequireWildcard(require("./views/DataGrid"));
+Object.keys(_DataGrid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DataGrid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DataGrid[key];
+    }
+  });
+});
+var _react = _interopRequireDefault(require("react"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const columns = [{
+  name: 'username',
+  title: 'Username',
+  editor: 'input'
+}, {
+  name: 'job',
+  title: 'Job'
+}, {
+  name: 'age',
+  title: 'Age',
+  editor: 'input'
+}, {
+  title: 'Example',
+  field: 'example',
+  editor: 'input'
+}];
+const leftColumns = ['username', 'row'];
+const customColumns = [{
+  name: 'job',
+  render: () => {
+    return _react.default.createElement("div", null, "test");
+  }
+}];
+const contextMenuItems = ['test'];
+function getData() {
+  const fd = [];
+  for (let index = 0; index < 5; index++) {
+    fd.push({
+      __table_id: String(index),
+      username: 'user-' + index,
+      age: 20
+    });
+    if (index % 5 == 0) {
+      fd.push({
+        __table_id: 's' + index,
+        __parent__table_id: String(index),
+        username: 'sub-user-' + index,
+        age: 20
+      });
+    }
+  }
+  return fd;
+}
+function ExampleGrid() {
+  const renderContactsGrid = ({
+    data
+  }) => {
+    return _react.default.createElement("div", null, _react.default.createElement("div", null, 'Test'));
+  };
+  const [selected, setSelected] = _react.default.useState(null);
+  const onSelectionChange = _react.default.useCallback(({
+    selected
+  }) => {
+    setSelected(selected);
+  }, []);
+  return _react.default.createElement(_DataGrid.default, {
+    dark: true,
+    allowChildRows: true,
+    onSelectionChange: onSelectionChange,
+    selected: selected,
+    contextMenuItems: contextMenuItems,
+    customColumns: customColumns,
+    columns: columns,
+    rows: getData(),
+    leftColumns: leftColumns,
+    gridOptions: {
+      rowIndexColumn: true,
+      checkboxColumn: true
+    }
+  });
+}
+var _default = ExampleGrid;
+exports.default = _default;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from './views/DataGrid';
+import AzGrid from './views/DataGrid';
+export default AzGrid;

package/dist/src/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _DataGrid = _interopRequireWildcard(require("./views/DataGrid"));
+Object.keys(_DataGrid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DataGrid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DataGrid[key];
+    }
+  });
+});
+var _example = _interopRequireDefault(require("./example"));
+var _react = _interopRequireDefault(require("react"));
+var _client = _interopRequireDefault(require("react-dom/client"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _default = _DataGrid.default;
+exports.default = _default;
+const root = _client.default.createRoot(document.getElementById('root'));
+root.render(_react.default.createElement(_example.default, null));

package/dist/src/views/DataGrid.d.ts

@@ -0,0 +1,54 @@
+import '@inovua/reactdatagrid-enterprise/index.css';
+import '@inovua/reactdatagrid-enterprise/theme/default-dark.css';
+import './theme/styles.css';
+import React from 'react';
+import { TypeColumn, TypeDataGridProps, TypeDataSource, TypeRowDetailsInfo, TypeRowProps, TypeRowSelection } from '@inovua/reactdatagrid-community/types';
+import { TypeOnSelectionChangeArg } from '@inovua/reactdatagrid-community/types/TypeDataGridProps';
+export type ColumnDefinition = TypeColumn;
+export type CellDefinition = any;
+export type RowDefinition = any;
+export type RowProps = TypeRowProps;
+export type RowSelectionValue = TypeRowSelection;
+export type DataRowDefinition = any;
+export type DataSourceDefinition = TypeDataSource;
+export type OnSelectionChangeFunc = (config: TypeOnSelectionChangeArg) => void;
+export type RowDetailsFunc = (rowDetailsInfo: TypeRowDetailsInfo) => React.ReactNode;
+type loose_column_fields = {
+    title: string;
+    key: string;
+    field: string;
+    columnName: string;
+    name: string;
+};
+export type LooseColumnDefinition = Partial<loose_column_fields & ColumnDefinition>;
+type columnOrString = string | LooseColumnDefinition;
+type customColumnData = {
+    name: string;
+    render: (cell: any, formatterParams: any, onRendered: any) => React.ReactNode;
+};
+type GridOptions = Partial<TypeDataGridProps>;
+type AzGridProps = {
+    columns?: columnOrString[];
+    rows?: any[];
+    licenseKey?: string;
+    gridOptions?: GridOptions;
+    tableColumnExtensions?: any[];
+    editableColumns?: string[];
+    leftColumns?: string[];
+    rightColumns?: string[];
+    customColumns?: customColumnData[];
+    contextMenuItems?: any[];
+    highlightedRow?: any;
+    RowDetail?: RowDetailsFunc;
+    get_rows?: () => any[];
+    selected?: RowSelectionValue;
+    onSelectionChange?: OnSelectionChangeFunc;
+    onRowsChange?: (rows: any[], options: any) => void;
+    onRowClick?: (rowIndex: number, row: any) => void;
+    onRowDoubleClick?: (rowIndex: number, row: any) => void;
+    dark?: boolean;
+    allowChildRows?: boolean;
+    className?: string;
+};
+export declare function AzGrid(props: AzGridProps): JSX.Element;
+export default AzGrid;

package/dist/src/views/DataGrid.js

@@ -0,0 +1,270 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AzGrid = AzGrid;
+exports.default = void 0;
+require("@inovua/reactdatagrid-enterprise/index.css");
+require("@inovua/reactdatagrid-enterprise/theme/default-dark.css");
+require("./theme/styles.css");
+var _react = _interopRequireDefault(require("react"));
+var _helpers = require("./func/helpers");
+var _controls = require("@azrico/controls");
+var _reactdatagridEnterprise = _interopRequireDefault(require("@inovua/reactdatagrid-enterprise"));
+var _clsx = _interopRequireDefault(require("clsx"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* -------------------------------------------------------------------------- */
+const defaultOptions = {
+  rowReorderColumn: false,
+  resizable: true,
+  rowIndexColumn: true
+};
+const forcedOptions = {
+  idProperty: '__table_id',
+  nodesProperty: '__children'
+};
+const defaultColumnOptions = {
+  draggable: false,
+  lockable: false
+};
+/* -------------------------------------------------------------------------- */
+function AzGrid(props) {
+  const [pendingChanges, set_pendingChanges] = _react.default.useState(1);
+  const [cached_rows, set_cached_rows] = _react.default.useState([]);
+  /* -------------------------------------------------------------------------- */
+  /*                                   Columns                                  */
+  /* -------------------------------------------------------------------------- */
+  const cached_columns = _react.default.useMemo(() => {
+    const final_columns = [];
+    let mcols = props.columns || [];
+    let mcolExts = props.tableColumnExtensions || [];
+    let rightColumns = props.rightColumns || [];
+    let leftColumns = props.leftColumns || [];
+    let editableColumns = props.editableColumns || [];
+    let customColumns = props.customColumns || [];
+    if (!Array.isArray(mcols)) return [];
+    /* ------------------------------- fix columns ------------------------------ */
+    mcols.map(r => {
+      if (typeof r === 'string') return {
+        field: r,
+        header: r
+      };
+      if (typeof r === 'object') {
+        let final_cl = {
+          name: r.field || r.name || r.key || r.columnName,
+          header: r.header || r.title || r.name || '-',
+          width: r.width || undefined
+        };
+        delete r.field;
+        delete r.key;
+        delete r.columnName;
+        final_cl = {
+          ...defaultColumnOptions,
+          ...r,
+          ...final_cl
+        };
+        return final_cl;
+      }
+      return null;
+    }).forEach(r => {
+      if (r != null) final_columns.push(r);
+    });
+    /* ---------------------------- apply extensions ---------------------------- */
+    if (mcolExts && Array.isArray(mcolExts)) for (let index = 0; index < mcolExts.length; index++) {
+      const ext = mcolExts[index];
+      const ext_cl = ext.columnName || ext.name || ext.field;
+      const mcol = final_columns.find(s => s.name === ext_cl);
+      if (!mcol) continue;
+      // if (ext.width) mcol.width = ext.width;
+      // if (ext.widthGrow) mcol.widthGrow = ext.widthGrow;
+    }
+    /* ------------------------------- frozen cols ------------------------------ */
+    if (Array.isArray(leftColumns)) {
+      for (let index = 0; index < leftColumns.length; index++) {
+        const r = leftColumns[index];
+        const mcol = final_columns.find(s => s.name === r);
+        if (mcol) {
+          mcol.locked = 'start';
+        }
+      }
+    }
+    if (Array.isArray(rightColumns)) {
+      for (let index = 0; index < rightColumns.length; index++) {
+        const r = rightColumns[index];
+        const mcol = final_columns.find(s => s.name === r);
+        if (mcol) {
+          mcol.locked = 'end';
+        }
+      }
+    }
+    /* -------------------------------- ediatable ------------------------------- */
+    if (Array.isArray(editableColumns)) {
+      for (let index = 0; index < editableColumns.length; index++) {
+        const r = editableColumns[index];
+        const mcol = final_columns.find(s => s.name === r);
+        if (mcol) {
+          // mcol.editor = editorWrapper;
+          // mcol.editorOptions = {
+          //     editOnClick: true,
+          // };
+        }
+      }
+    }
+    if (Array.isArray(customColumns)) {
+      for (let index = 0; index < customColumns.length; index++) {
+        const r = customColumns[index];
+        const mcol = final_columns.find(s => s.name === r.name);
+        if (mcol) {
+          //@ts-ignore
+          mcol.render = r.render;
+        }
+      }
+    }
+    return final_columns;
+  }, [props.columns, props.leftColumns, props.editableColumns, props.tableColumnExtensions]);
+  /* -------------------------------------------------------------------------- */
+  /* -------------------------------------------------------------------------- */
+  /*                                 Row changes                                */
+  /* -------------------------------------------------------------------------- */
+  _react.default.useEffect(() => {
+    if (pendingChanges <= 0) return;
+    let new_rows = [];
+    if (typeof props.get_rows === 'function') {
+      new_rows = props.get_rows();
+    } else new_rows = props.rows || [];
+    /* -------------------------------------------------------------------------- */
+    if (!Array.isArray(new_rows)) new_rows = [];
+    /* -------------------------- fix child parent rel -------------------------- */
+    if (props.allowChildRows) new_rows = (0, _helpers.fix_parent_child_relations)(new_rows);
+    set_cached_rows(new_rows);
+    set_pendingChanges(0);
+  }, [pendingChanges]);
+  _react.default.useEffect(() => {
+    set_pendingChanges(r => r + 1);
+  }, [props.rows]);
+  function onRowsChange(rows, options) {
+    if (props.onRowsChange) props.onRowsChange(rows, options);
+    set_pendingChanges(r => r + 1); //notify the cache to update rows after we made changes to them
+  }
+  /* -------------------------------------------------------------------------- */
+  /* -------------------------------------------------------------------------- */
+  return _react.default.createElement(DataGrid, {
+    ...props,
+    columns: cached_columns,
+    rows: cached_rows,
+    onRowsChange: onRowsChange,
+    highlightedRow: props.highlightedRow
+  });
+}
+/* -------------------------------------------------------------------------- */
+function DataGrid(props) {
+  const {
+    columns,
+    rows,
+    highlightedRow,
+    dark,
+    contextMenuItems,
+    onRowsChange
+  } = props;
+  /* -------------------------------------------------------------------------- */
+  const gridRef = _react.default.useRef(null);
+  const [menuAnchorEl, set_menuAnchorEl] = _react.default.useState(null);
+  const [menuRow, set_menuRow] = _react.default.useState(null);
+  const gridID = _react.default.useMemo(() => 'table-' + Date.now().valueOf(), []);
+  /* -------------------------------------------------------------------------- */
+  /*                               Create the grid                              */
+  /* -------------------------------------------------------------------------- */
+  const static_gridOptions = _react.default.useMemo(() => {
+    const firstcolumn = columns[0];
+    const licenseKey = props.licenseKey || get_default_key();
+    const events = {
+      onRowClick: onRowClick,
+      onRowDoubleClick: onRowDoubleClick,
+      onRowContextMenu: onRowContextMenu
+    };
+    const extra_ops = {
+      onSelectionChange: props.onSelectionChange,
+      licenseKey: licenseKey,
+      treeColumn: props.allowChildRows ? firstcolumn.name : undefined,
+      renderRowDetails: props.RowDetail,
+      theme: dark ? 'default-dark' : 'default-light'
+    };
+    return {
+      ...defaultOptions,
+      ...events,
+      ...extra_ops,
+      ...props.gridOptions,
+      ...forcedOptions
+    };
+  }, [props.gridOptions]);
+  const dynamic_gridOptions = _react.default.useMemo(() => {
+    return {
+      selected: props.selected
+    };
+  }, [props.selected]);
+  /* ------------------------------- load events ------------------------------ */
+  function onCellEdit(cell) {}
+  function onRowContextMenu(row, ev) {
+    if (_helpers.func_selection.has_selection()) return;
+    update_menuAnchorEl(_helpers.func_selection.getVirtualElement(ev.clientX, ev.clientY));
+    update_menuRow(row.data);
+    ev.preventDefault();
+  }
+  function onRowClick(row, event) {
+    props.onRowClick && props.onRowClick(row.rowIndex, row.data);
+  }
+  function onRowDoubleClick(event, row) {
+    props.onRowDoubleClick && props.onRowDoubleClick(row.rowIndex, row.data);
+  }
+  /* ------------------------- update the selected row ------------------------ */
+  _react.default.useEffect(() => {
+    if (highlightedRow) gridRef.current.scrollToRow(getRowIndex(highlightedRow, rows));
+  }, [highlightedRow]);
+  /* ------------------------------- ContextMenu ------------------------------ */
+  function update_menuAnchorEl(el) {
+    if (!el) {
+      set_menuAnchorEl(el);
+    } else if (menuAnchorEl) set_menuAnchorEl(null);
+  }
+  function update_menuRow(r) {
+    if (!r) {
+      set_menuRow(r);
+    } else if (menuRow) set_menuRow(null);
+  }
+  /* -------------------------------------------------------------------------- */
+  // const { width, height, ref: resize_ref } = useResizeDetector();
+  return _react.default.createElement("div", {
+    className: (0, _clsx.default)(props.className, 'azgrid-nooverflow', 'azgrid-filler')
+  }, _react.default.createElement(_reactdatagridEnterprise.default, {
+    ...static_gridOptions,
+    ...dynamic_gridOptions,
+    className: 'azgrid-filler',
+    columns: columns,
+    dataSource: rows
+  }), _react.default.createElement(_controls.ContextMenu, {
+    menuAnchorEl: menuAnchorEl,
+    set_menuAnchorEl: update_menuAnchorEl,
+    menuRow: menuRow,
+    items: contextMenuItems
+  }));
+}
+/* -------------------------------------------------------------------------- */
+function get_default_key() {
+  return 'ExpiryDate=2999-01-01,Z=1040577552';
+}
+function getRowIndex(row, allrows) {
+  if (!allrows) return -1;
+  return allrows.findIndex(s => rowKeyGetter(s) === rowKeyGetter(row)) || -1;
+}
+function rowKeyGetter(row) {
+  return row.__uid;
+}
+function isRowSelected(row, highlightedRow) {
+  const rid = rowKeyGetter(row);
+  const highLight = rowKeyGetter(highlightedRow);
+  return rid != null && rid === highLight;
+}
+/* -------------------------------------------------------------------------- */
+var _default = AzGrid;
+exports.default = _default;

package/dist/src/views/func/helpers.d.ts

@@ -0,0 +1,29 @@
+type mrow = {
+    __parent__table_id: any;
+    __table_id: any;
+    __children?: any[];
+};
+export declare function fix_parent_child_relations<T extends mrow>(rows: T[]): T[];
+export declare class func_selection {
+    static getVirtualElement(x?: number, y?: number): () => {
+        getBoundingClientRect: () => {
+            width: number;
+            height: number;
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+    };
+    static generateGetBoundingClientRect(x?: number, y?: number): () => {
+        width: number;
+        height: number;
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    static get_selectedText(): string;
+    static has_selection(): boolean;
+}
+export {};

package/dist/src/views/func/helpers.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fix_parent_child_relations = fix_parent_child_relations;
+exports.func_selection = void 0;
+//given an array of rows, fixes parent,child relations
+function fix_parent_child_relations(rows) {
+  if (!Array.isArray(rows)) rows = [];
+  const child_rows = [];
+  const parent_rows = [];
+  for (let index = 0; index < rows.length; index++) {
+    const r = rows[index];
+    if (r.__parent__table_id != undefined) child_rows.push(r);else parent_rows.push(r);
+  }
+  for (let index = 0; index < parent_rows.length; index++) {
+    const pr = parent_rows[index];
+    pr.__children = [];
+  }
+  //find parent for these children !
+  for (let index = 0; index < child_rows.length; index++) {
+    const child = child_rows[index];
+    const parentOfChild = parent_rows.find(s => s.__table_id == child.__parent__table_id);
+    if (!parentOfChild) continue; //no parent :(
+    //@ts-ignore
+    parentOfChild.__children.push(child);
+  }
+  for (let index = 0; index < parent_rows.length; index++) {
+    const pr = parent_rows[index];
+    //@ts-ignore
+    if (pr.__children.length == 0) pr.__children = undefined;
+  }
+  return parent_rows;
+}
+class func_selection {
+  static getVirtualElement(x = 0, y = 0) {
+    return () => ({
+      getBoundingClientRect: func_selection.generateGetBoundingClientRect(x, y)
+    });
+  }
+  static generateGetBoundingClientRect(x = 0, y = 0) {
+    return () => ({
+      width: 0,
+      height: 0,
+      top: y,
+      right: x,
+      bottom: y,
+      left: x
+    });
+  }
+  static get_selectedText() {
+    var text = '';
+    if (window.getSelection) {
+      var _window$getSelection;
+      text = (_window$getSelection = window.getSelection()) === null || _window$getSelection === void 0 ? void 0 : _window$getSelection.toString();
+    } else if (document.selection && document.selection.type != 'Control') {
+      var _document$selection$c;
+      text = (_document$selection$c = document.selection.createRange()) === null || _document$selection$c === void 0 ? void 0 : _document$selection$c.text;
+    }
+    return text || '';
+  }
+  static has_selection() {
+    const slct = window.getSelection();
+    if (slct == null) return false;
+    if (slct.type == null) return func_selection.get_selectedText().length !== 0;
+    if (slct.type === 'Range') return true;
+    return false;
+  }
+}
+exports.func_selection = func_selection;

package/dist/src/views/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DataGrid';
+import AzGrid from './DataGrid';
+export default AzGrid;

package/dist/src/views/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports.default = void 0;
+var _DataGrid = _interopRequireWildcard(require("./DataGrid"));
+Object.keys(_DataGrid).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _DataGrid[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _DataGrid[key];
+    }
+  });
+});
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _default = _DataGrid.default;
+exports.default = _default;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@azrico/reactgrid",
-	"version": "1.0.2",
-	"main": "src/test",
+	"version": "1.0.3",
+	"main": "dist/index.js",
 	"description": "React Datagrid",
 	"author": "Azrideus <MehrdadTavangar@gmail.com>",
 	"homepage": ".",