linear-react-components-ui 1.1.25-rc.2 → 1.1.26-beta-1

package/lib/table/RowColumn.js

@@ -1,81 +1,46 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _helpers = require("./helpers");
-var _skeleton = _interopRequireDefault(require("../skeleton"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function getColClickEvent(event, _ref) {
-  let {
-    ignoreTableColClick,
-    handleTableColClick,
-    onClick,
-    dataId
-  } = _ref;
-  if (ignoreTableColClick) return undefined;
-  if (onClick) {
-    return onClick(event, dataId);
-  } else if (handleTableColClick) {
-    return handleTableColClick(event, dataId);
+import { j as a } from "../chunks/jsx-runtime.CYK1ROHF.js";
+import { useContext as h, useCallback as y } from "react";
+import g from "../skeleton/index.js";
+import { RowContext as j } from "./helpers.js";
+function R(e, {
+  ignoreTableColClick: r,
+  handleTableColClick: t,
+  onClick: n,
+  dataId: o
+}) {
+  if (!r) {
+    if (n)
+      return n(e, o);
+    if (t)
+      return t(e, o);
   }
-  return undefined;
 }
-const displayClass = {
-  never: 'hidden',
-  onRowHover: 'rowhover'
-};
-const RowColumn = props => {
-  const {
-    customClass,
-    style,
-    displayContent = 'always',
-    textAlign,
-    visible = true,
-    rowSpan,
-    colSpan,
-    children,
-    isMenuColumn = false
-  } = props;
-  const context = (0, _react.useContext)(_helpers.RowContext);
+const d = { never: "hidden", onRowHover: "rowhover" }, B = (e) => {
   const {
-    skeletonize,
-    vertical,
-    skeletonInRows = 10
-  } = context;
-  const hiddenContent = displayContent !== 'always';
-  const renderContent = (0, _react.useCallback)(() => {
-    if (skeletonize && vertical) {
-      return /*#__PURE__*/_react.default.createElement(_skeleton.default, {
-        height: 16,
-        style: {
-          marginBottom: 0
-        }
-      });
+    customClass: r,
+    style: t,
+    displayContent: n = "always",
+    textAlign: o,
+    visible: f = !0,
+    rowSpan: c,
+    colSpan: x,
+    children: s,
+    isMenuColumn: p = !1
+  } = e, l = h(j), { skeletonize: i, vertical: u, skeletonInRows: w = 10 } = l, m = n !== "always", C = y(() => i && u ? /* @__PURE__ */ a.jsx(g, { height: 16, style: { marginBottom: 0 } }) : m && n ? /* @__PURE__ */ a.jsx("span", { className: d[n], children: s }) : s, [i, u, s, n, m, d]);
+  return !f || i && !w && !u ? null : /* @__PURE__ */ a.jsx(
+    "td",
+    {
+      rowSpan: c,
+      colSpan: x,
+      className: `rowcolumn ${r} text-align-${o} ${!l.rowBorder && " -noborder"} ${c ? "" : " -norowspan"} ${p && "menu-column"}`,
+      style: t,
+      onClick: (v) => R(v, { ...l, ...e }),
+      role: "presentation",
+      tabIndex: -1,
+      children: C()
     }
-    return hiddenContent && displayContent ? /*#__PURE__*/_react.default.createElement("span", {
-      className: displayClass[displayContent]
-    }, children) : children;
-  }, [skeletonize, vertical, children, displayContent, hiddenContent, displayClass]);
-  if (!visible) return null;
-  if (skeletonize && !skeletonInRows && !vertical) return null;
-  return /*#__PURE__*/_react.default.createElement("td", {
-    rowSpan: rowSpan,
-    colSpan: colSpan,
-    className: `rowcolumn ${customClass} text-align-${textAlign} ${!context.rowBorder && ' -noborder'} ${!rowSpan ? ' -norowspan' : ''} ${isMenuColumn && 'menu-column'}`,
-    style: style,
-    onClick: e => getColClickEvent(e, _objectSpread(_objectSpread({}, context), props)),
-    role: "presentation",
-    tabIndex: -1
-  }, renderContent());
+  );
+};
+export {
+  B as default
 };
-var _default = exports.default = RowColumn;

package/lib/table/helpers.d.ts

@@ -1,8 +1,7 @@
-import React__default from 'react';
-import { ITableContext, ITableRowContext } from './types.js';
-
-declare const TableContext: React__default.Context<ITableContext>;
-declare const RowContext: React__default.Context<ITableRowContext>;
+import { default as React } from 'react';
+import { ITableContext, ITableRowContext } from './types';
+declare const TableContext: React.Context<ITableContext>;
+declare const RowContext: React.Context<ITableRowContext>;
 declare const getArrayFromNumber: (number: number) => number[];
-
-export { RowContext, TableContext as default, getArrayFromNumber };
+export default TableContext;
+export { RowContext, getArrayFromNumber };

package/lib/table/helpers.js

@@ -1,15 +1,7 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getArrayFromNumber = exports.default = exports.RowContext = void 0;
-var _react = _interopRequireDefault(require("react"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const TableContext = /*#__PURE__*/_react.default.createContext({});
-const RowContext = exports.RowContext = /*#__PURE__*/_react.default.createContext({});
-const getArrayFromNumber = number => Array.from({
-  length: number
-}, (_, i) => i + 1);
-exports.getArrayFromNumber = getArrayFromNumber;
-var _default = exports.default = TableContext;
+import t from "react";
+const n = t.createContext({}), c = t.createContext({}), m = (e) => Array.from({ length: e }, (r, o) => o + 1);
+export {
+  c as RowContext,
+  n as default,
+  m as getArrayFromNumber
+};

package/lib/table/index.d.ts

@@ -1,11 +1,9 @@
-export { default as THeader } from './Header.js';
-export { default as TRow } from './Row.js';
-export { default as TBody } from './Body.js';
-export { default as Th } from './HeaderColumn.js';
-export { default as Td } from './RowColumn.js';
-import { ITableProps } from './types.js';
-import 'react';
-
-declare const Table: ({ children, ...props }: ITableProps) => JSX.Element;
-
-export { Table as default };
+import { default as THeader } from './Header';
+import { default as TRow } from './Row';
+import { default as TBody } from './Body';
+import { default as Th } from './HeaderColumn';
+import { default as Td } from './RowColumn';
+import { ITableProps } from './types';
+declare const Table: ({ children, ...props }: ITableProps) => import("react/jsx-runtime").JSX.Element;
+export default Table;
+export { THeader, TRow, TBody, Th, Td, };

package/lib/table/index.js

@@ -1,158 +1,109 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "TBody", {
-  enumerable: true,
-  get: function () {
-    return _Body.default;
-  }
-});
-Object.defineProperty(exports, "THeader", {
-  enumerable: true,
-  get: function () {
-    return _Header.default;
-  }
-});
-Object.defineProperty(exports, "TRow", {
-  enumerable: true,
-  get: function () {
-    return _Row.default;
-  }
-});
-Object.defineProperty(exports, "Td", {
-  enumerable: true,
-  get: function () {
-    return _RowColumn.default;
-  }
-});
-Object.defineProperty(exports, "Th", {
-  enumerable: true,
-  get: function () {
-    return _HeaderColumn.default;
-  }
-});
-exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
-var _lodash = _interopRequireDefault(require("lodash"));
-var _Header = _interopRequireDefault(require("./Header"));
-var _Row = _interopRequireDefault(require("./Row"));
-var _Body = _interopRequireDefault(require("./Body"));
-var _HeaderColumn = _interopRequireDefault(require("./HeaderColumn"));
-var _RowColumn = _interopRequireDefault(require("./RowColumn"));
-require("../assets/styles/table.scss");
-var _helpers = _interopRequireDefault(require("./helpers"));
-const _excluded = ["children"],
-  _excluded2 = ["onColClick", "onRowClick", "bodyScrollable", "vertical", "skeletonize", "strict", "skeletonHeight", "skeletonInHeader", "skeletonInRows", "selectedRowId", "allowHorizontalScroll"];
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var n = Object.getOwnPropertySymbols(e); for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (-1 !== e.indexOf(n)) continue; t[n] = r[n]; } return t; }
-// TODO - Precisa finalizar o scroll no corpo da tabela.
-const getClass = _ref => {
-  let {
-    customClass,
-    striped,
-    bordered,
-    hovered,
-    skeletonize,
-    headerColored,
-    condensed,
-    vertical,
-    bodyScrollable,
-    skeletonInRows = 10
-  } = _ref;
-  return `table-component ${customClass} ${striped && '-striped'} 
-  ${bordered && '-bordered'} ${hovered && '-hovered'} ${headerColored && '-headercolor'}
-  ${condensed && '-condensed'}
-  ${vertical && '-vertical'}
-  ${skeletonize && !skeletonInRows ? '-skeletonized' : ''}
-  ${bodyScrollable ? '-scrollable' : ''}`;
-};
-const Table = _ref2 => {
-  let {
-      children
-    } = _ref2,
-    props = _objectWithoutProperties(_ref2, _excluded);
+import { j as b } from "../chunks/jsx-runtime.CYK1ROHF.js";
+import { useState as f, useRef as P, useCallback as C, useMemo as V, useEffect as S } from "react";
+import W from "lodash";
+import { default as Z } from "./Header.js";
+import { default as te } from "./Row.js";
+import { default as se } from "./Body.js";
+import { default as ne } from "./HeaderColumn.js";
+import { default as re } from "./RowColumn.js";
+import '../assets/table.css';/* empty css                       */
+import F from "./helpers.js";
+const v = ({
+  customClass: l,
+  striped: t,
+  bordered: n,
+  hovered: d,
+  skeletonize: r,
+  headerColored: c,
+  condensed: a,
+  vertical: o,
+  bodyScrollable: i,
+  skeletonInRows: m = 10
+}) => `table-component ${l} ${t && "-striped"} 
+  ${n && "-bordered"} ${d && "-hovered"} ${c && "-headercolor"}
+  ${a && "-condensed"}
+  ${o && "-vertical"}
+  ${r && !m ? "-skeletonized" : ""}
+  ${i ? "-scrollable" : ""}`, U = ({ children: l, ...t }) => {
   const {
-      onColClick,
-      onRowClick,
-      bodyScrollable,
-      vertical,
-      skeletonize,
-      strict,
-      skeletonHeight,
-      skeletonInHeader,
-      skeletonInRows,
-      selectedRowId: selectedRowIdFromProps,
-      allowHorizontalScroll = false
-    } = props,
-    rest = _objectWithoutProperties(props, _excluded2);
-  const [selectedRowId, setSelectedRowId] = (0, _react.useState)(selectedRowIdFromProps);
-  const [bodyScrollWidth, setBodyScrollWidth] = (0, _react.useState)(0);
-  const [columnsWidth, setColumnsWidth] = (0, _react.useState)([]);
-  const [columnsCount, setColumnsCount] = (0, _react.useState)(0);
-  const bodyContainerRef = (0, _react.useRef)(null);
-  const handleSelectRow = (0, _react.useCallback)(selectedId => {
-    setSelectedRowId(selectedId);
-  }, []);
-  const handlerSetColumnsWidth = (0, _react.useCallback)(widths => {
-    if (!_lodash.default.isEmpty(widths) && _lodash.default.isEmpty(columnsWidth)) setColumnsWidth(widths);
-  }, [columnsWidth]);
-  const handlerSetColumnsCount = (0, _react.useCallback)(count => setColumnsCount(count), []);
-  const getContextValues = (0, _react.useCallback)(() => ({
-    bodyContainerRef,
-    bodyScrollWidth,
-    selectedRowId,
-    vertical,
-    skeletonize,
-    skeletonHeight,
-    skeletonInHeader,
-    skeletonInRows,
-    strict,
-    columnsCount,
-    handleSelectRow,
-    handleTableColClick: onColClick,
-    handleTableRowClick: onRowClick,
-    handlerSetColumnsWidth,
-    columnsWidth,
-    handlerSetColumnsCount
-  }), [bodyContainerRef, bodyScrollWidth, selectedRowId, vertical, skeletonize, skeletonHeight, skeletonInHeader, skeletonInRows, strict, columnsCount, handleSelectRow, onColClick, onRowClick, handlerSetColumnsWidth, columnsWidth, handlerSetColumnsCount]);
-  const getTableComponent = () => {
-    const tableComponent = /*#__PURE__*/_react.default.createElement(_react.Fragment, null, /*#__PURE__*/_react.default.createElement("table", _extends({
-      style: {
-        contain: strict ? 'strict' : 'size style'
-      },
-      className: getClass(props)
-    }, rest), children));
-    if (allowHorizontalScroll) {
-      return /*#__PURE__*/_react.default.createElement("div", {
-        className: "horizontal-scroll-container"
-      }, tableComponent);
+    onColClick: n,
+    onRowClick: d,
+    bodyScrollable: r,
+    vertical: c,
+    skeletonize: a,
+    strict: o,
+    skeletonHeight: i,
+    skeletonInHeader: m,
+    skeletonInRows: x,
+    customClass: M,
+    bordered: _,
+    hovered: q,
+    headerColored: A,
+    condensed: D,
+    selectedRowId: j,
+    striped: G,
+    ...E
+  } = t, [R, k] = f(j), [h, g] = f(0), [u, z] = f([]), [p, H] = f(0), s = P(null), w = C((e) => {
+    k(e);
+  }, []), y = C((e) => {
+    !W.isEmpty(e) && W.isEmpty(u) && z(e);
+  }, [u]), T = C((e) => H(e), []), $ = C(() => ({
+    bodyContainerRef: s,
+    bodyScrollWidth: h,
+    selectedRowId: R,
+    vertical: c,
+    skeletonize: a,
+    skeletonHeight: i,
+    skeletonInHeader: m,
+    skeletonInRows: x,
+    strict: o,
+    columnsCount: p,
+    handleSelectRow: w,
+    handleTableColClick: n,
+    handleTableRowClick: d,
+    handlerSetColumnsWidth: y,
+    columnsWidth: u,
+    handlerSetColumnsCount: T
+  }), [
+    s,
+    h,
+    R,
+    c,
+    a,
+    i,
+    m,
+    x,
+    o,
+    p,
+    w,
+    n,
+    d,
+    y,
+    u,
+    T
+  ]), B = V(() => $(), [$]);
+  return S(() => {
+    if (r && s && s.current) {
+      const { offsetWidth: e, clientWidth: N } = s.current, I = e - N;
+      I !== h && g(I);
     }
-    return tableComponent;
-  };
-  const contextValues = (0, _react.useMemo)(() => getContextValues(), [getContextValues]);
-  (0, _react.useEffect)(() => {
-    if (bodyScrollable && bodyContainerRef && bodyContainerRef.current) {
-      const {
-        offsetWidth,
-        clientWidth
-      } = bodyContainerRef.current;
-      const scrollWidth = offsetWidth - clientWidth;
-      if (scrollWidth !== bodyScrollWidth) setBodyScrollWidth(scrollWidth);
+  }, []), S(() => {
+    k(t.selectedRowId);
+  }, [t.selectedRowId]), /* @__PURE__ */ b.jsx(F.Provider, { value: B, children: r ? /* @__PURE__ */ b.jsx("div", { className: v(t), children: l }) : /* @__PURE__ */ b.jsx(
+    "table",
+    {
+      style: { contain: o ? "strict" : "size style" },
+      className: v(t),
+      ...E,
+      children: l
     }
-  }, []);
-  (0, _react.useEffect)(() => {
-    setSelectedRowId(props.selectedRowId);
-  }, [props.selectedRowId]);
-  return /*#__PURE__*/_react.default.createElement(_helpers.default.Provider, {
-    value: contextValues
-  }, bodyScrollable ? /*#__PURE__*/_react.default.createElement("div", {
-    className: getClass(props)
-  }, children) : getTableComponent());
+  ) });
+};
+export {
+  se as TBody,
+  Z as THeader,
+  te as TRow,
+  re as Td,
+  ne as Th,
+  U as default
 };
-var _default = exports.default = Table;

package/lib/table/table.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/table/types.d.ts

@@ -1,6 +1,5 @@
-import { TableHTMLAttributes, ReactNode, ComponentProps, MouseEvent, CSSProperties, LegacyRef, SetStateAction } from 'react';
-
-interface ITableProps extends TableHTMLAttributes<HTMLTableElement> {
+import { CSSProperties, ReactNode, TableHTMLAttributes, MouseEvent, SetStateAction, LegacyRef, ComponentProps } from 'react';
+export interface ITableProps extends TableHTMLAttributes<HTMLTableElement> {
     children?: ReactNode;
     striped?: boolean;
     customClass?: string;
@@ -18,9 +17,8 @@ interface ITableProps extends TableHTMLAttributes<HTMLTableElement> {
     skeletonInRows?: number;
     skeletonInHeader?: boolean;
     skeletonHeight?: number;
-    allowHorizontalScroll?: boolean;
 }
-interface ITableHeaderProps extends ComponentProps<'th'> {
+export interface ITableHeaderProps extends ComponentProps<'th'> {
     children?: ReactNode;
     customClass?: string;
     textAlign?: string;
@@ -28,7 +26,7 @@ interface ITableHeaderProps extends ComponentProps<'th'> {
     id?: string;
     isMenuColumn?: boolean;
 }
-interface ITableBodyProps extends TableHTMLAttributes<HTMLTableElement> {
+export interface ITableBodyProps extends TableHTMLAttributes<HTMLTableElement> {
     children?: ReactNode;
     customClass?: string;
     columnsCount?: number;
@@ -37,7 +35,7 @@ interface ITableBodyProps extends TableHTMLAttributes<HTMLTableElement> {
     skeletonInRows?: number;
     skeletonHeight?: number;
 }
-interface ITableRowProps extends Pick<TableHTMLAttributes<HTMLTableRowElement>, 'onMouseEnter' | 'onMouseLeave'> {
+export interface ITableRowProps extends Pick<TableHTMLAttributes<HTMLTableRowElement>, 'onMouseEnter' | 'onMouseLeave'> {
     children?: ReactNode;
     color?: string;
     customClass?: string;
@@ -61,7 +59,7 @@ interface ITableRowProps extends Pick<TableHTMLAttributes<HTMLTableRowElement>,
     colSpan?: number;
     isMenuColumn?: boolean;
 }
-interface ITableContext {
+export interface ITableContext {
     bodyScrollable?: boolean;
     skeletonInRows?: number;
     bodyContainerRef?: LegacyRef<HTMLDivElement>;
@@ -81,18 +79,16 @@ interface ITableContext {
     handlerSetColumnsCount?: (count: number) => void;
     tableContainer?: HTMLTableElement | null;
 }
-interface ITableRowContext {
+export interface ITableRowContext {
     skeletonize?: boolean;
     vertical?: boolean;
     skeletonInRows?: number;
     rowBorder?: boolean;
 }
-type TableElement = {
+export type TableElement = {
     props: {
         style: {
             width: string | number;
         };
     };
 };
-
-export { ITableBodyProps, ITableContext, ITableHeaderProps, ITableProps, ITableRowContext, ITableRowProps, TableElement };

package/lib/tabs/DropdownTabs.d.ts

@@ -1,11 +1,3 @@
-import { DropdownProps } from './types.js';
-import 'react';
-import '../@types/Size.js';
-import '../@types/Position.js';
-import '../@types/PermissionAttr.js';
-import '../@types/Icon.js';
-import '../icons/helper.js';
-
-declare const DropdownTabs: ({ tabs, tabMenuSize, }: DropdownProps) => JSX.Element | null;
-
-export { DropdownTabs as default };
+import { DropdownProps } from './types';
+declare const DropdownTabs: ({ tabs, tabMenuSize, }: DropdownProps) => import("react/jsx-runtime").JSX.Element | null;
+export default DropdownTabs;