@ztwoint/z-ui 0.1.27 → 0.1.28

package/dist/components/table/components/pagination/pagination.js

@@ -0,0 +1,112 @@
+import { jsxs as I, jsx as s } from "react/jsx-runtime";
+import { usePagination as S } from "./pagination.hook.js";
+import { PAGINATION_LABELS as o, PAGINATION_DEFAULTS as x, PAGINATION_CSS_CLASSES as E } from "./pagination.const.js";
+import { Button as d } from "../../../button/button.js";
+import k from "../../../assets/icons/chevron-left.js";
+import N from "../../../assets/icons/chevron-right.js";
+import L from "../../../assets/icons/double-chevron-left.js";
+import _ from "../../../assets/icons/double-chevron-right.js";
+import "react";
+import { cn as z } from "../../../../lib/utils.js";
+const p = () => /* @__PURE__ */ s("span", { className: E.ellipsis, children: "..." }), V = ({
+  currentPage: i,
+  totalPage: r,
+  onChange: b,
+  disabled: t = !1
+}) => {
+  const { visiblePages: m, hasEllipsisStart: v, hasEllipsisEnd: A } = S({
+    currentPage: i,
+    totalPage: r,
+    maxVisiblePages: x.MAX_VISIBLE_PAGES
+  });
+  if (r <= 1)
+    return null;
+  const f = i === 1, c = i === r, a = (e) => {
+    !t && e !== i && e >= 1 && e <= r && b(e);
+  }, C = () => {
+    const e = [];
+    let h = !1, u = !1;
+    return m.forEach((l, y) => {
+      v && l === m[1] && !h && (e.push(/* @__PURE__ */ s(p, {}, "ellipsis-start")), h = !0);
+      const n = l === i;
+      e.push(
+        /* @__PURE__ */ s(
+          d,
+          {
+            onClick: () => a(l),
+            variant: "stroke",
+            shade: n ? "brand" : "neutral",
+            size: "small",
+            "aria-label": `${o.page} ${l}`,
+            "aria-current": n ? "page" : void 0,
+            className: z(
+              "min-w-[29px] text-text-neutral-secondary",
+              n && "border border-button-primary-brand-surface-default"
+            ),
+            style: {
+              borderStyle: n ? "solid" : "none",
+              boxShadow: n ? "none" : ""
+            },
+            children: l
+          },
+          l
+        )
+      ), A && l === m[m.length - 2] && !u && (e.push(/* @__PURE__ */ s(p, {}, "ellipsis-end")), u = !0);
+    }), e;
+  };
+  return /* @__PURE__ */ I("div", { className: "flex gap-1", children: [
+    /* @__PURE__ */ s(
+      d,
+      {
+        "aria-label": o.first,
+        onClick: () => a(1),
+        disabled: t || f,
+        variant: "stroke",
+        shade: "neutral",
+        size: "small",
+        leftIcon: /* @__PURE__ */ s(L, {})
+      }
+    ),
+    /* @__PURE__ */ s(
+      d,
+      {
+        "aria-label": o.previous,
+        onClick: () => a(i - 1),
+        disabled: t || f,
+        variant: "stroke",
+        shade: "neutral",
+        size: "small",
+        leftIcon: /* @__PURE__ */ s(k, {})
+      }
+    ),
+    C(),
+    /* @__PURE__ */ s(
+      d,
+      {
+        "aria-label": o.next,
+        onClick: () => a(i + 1),
+        disabled: t || c,
+        variant: "stroke",
+        shade: "neutral",
+        size: "small",
+        leftIcon: /* @__PURE__ */ s(N, {})
+      }
+    ),
+    /* @__PURE__ */ s(
+      d,
+      {
+        "aria-label": o.last,
+        onClick: () => a(r),
+        disabled: t || c,
+        variant: "stroke",
+        shade: "neutral",
+        size: "small",
+        leftIcon: /* @__PURE__ */ s(_, {})
+      }
+    )
+  ] });
+};
+export {
+  V as Pagination,
+  V as default
+};

package/dist/components/table/components/pagination/pagination.type.d.ts

@@ -0,0 +1,33 @@
+export interface PaginationProps {
+    currentPage: number;
+    totalPage: number;
+    onChange: (page: number) => void;
+    itemsPerPage?: number;
+    totalItems?: number;
+    showPageSizeSelector?: boolean;
+    showQuickJumper?: boolean;
+    showTotal?: boolean;
+    disabled?: boolean;
+}
+export interface PaginationHookProps {
+    currentPage: number;
+    totalPage: number;
+    maxVisiblePages?: number;
+}
+export interface PaginationHookReturn {
+    visiblePages: number[];
+    hasEllipsisStart: boolean;
+    hasEllipsisEnd: boolean;
+}
+export interface PaginationInfoProps {
+    showTotal: boolean;
+    totalItems?: number;
+    currentPage: number;
+    itemsPerPage: number;
+}
+export interface PaginationQuickJumperProps {
+    disabled: boolean;
+    currentPage: number;
+    totalPage: number;
+    onChange: (page: number) => void;
+}

package/dist/components/table/components/pagination/pagination.utils.d.ts

@@ -0,0 +1,7 @@
+import { PaginationHookProps, PaginationHookReturn } from './pagination.type';
+export declare const calculateVisiblePages: ({ currentPage, totalPage, maxVisiblePages, }: PaginationHookProps) => PaginationHookReturn;
+export declare const calculateItemRange: (currentPage: number, itemsPerPage: number, totalItems: number) => {
+    start: number;
+    end: number;
+};
+export declare const isValidPageNumber: (page: number, totalPage: number) => boolean;

package/dist/components/table/components/pagination/pagination.utils.js

@@ -0,0 +1,35 @@
+import { PAGINATION_DEFAULTS as p } from "./pagination.const.js";
+const M = ({
+  currentPage: i,
+  totalPage: s,
+  maxVisiblePages: n = p.MAX_VISIBLE_PAGES
+}) => {
+  if (s <= n)
+    return {
+      visiblePages: Array.from({ length: s }, (f, m) => m + 1),
+      hasEllipsisStart: !1,
+      hasEllipsisEnd: !1
+    };
+  const h = Math.floor((n - 3) / 2);
+  let r = Math.max(2, i - h), t = Math.min(s - 1, i + h);
+  i <= h + 2 && (t = Math.min(s - 1, n - 2), r = 2), i >= s - h - 1 && (r = Math.max(2, s - n + 3), t = s - 1);
+  const c = [];
+  s > 0 && c.push(1);
+  const l = r > 2;
+  for (let f = r; f <= t; f++)
+    f !== 1 && f !== s && c.push(f);
+  const E = t < s - 1;
+  return s > 1 && c.push(s), {
+    visiblePages: c,
+    hasEllipsisStart: l,
+    hasEllipsisEnd: E
+  };
+}, d = (i, s, n) => {
+  const h = (i - 1) * s + 1, r = Math.min(i * s, n);
+  return { start: h, end: r };
+}, A = (i, s) => i >= 1 && i <= s && Number.isInteger(i);
+export {
+  d as calculateItemRange,
+  M as calculateVisiblePages,
+  A as isValidPageNumber
+};

package/dist/components/table/components/table-cell.d.ts

@@ -0,0 +1,15 @@
+import { CellValue, CellType, CellRenderer, TableProps } from '../table.type';
+import * as React from 'react';
+interface TableCellProps {
+    value: CellValue;
+    cellType: CellType;
+    cellRenderer?: CellRenderer;
+    customCells?: Record<string, CellRenderer>;
+    record: Record<string, unknown>;
+    index: number;
+    align?: 'left' | 'center' | 'right';
+    width?: string | number;
+    cell: TableProps['cell'];
+}
+export declare const TableCell: React.FC<TableCellProps>;
+export {};

package/dist/components/table/components/table-cell.js

@@ -0,0 +1,45 @@
+import { jsx as l } from "react/jsx-runtime";
+import { TABLE_CSS_CLASSES as r } from "../table.const.js";
+import { TextCell as p } from "./cell/text-cell.js";
+import { NumberCell as h } from "./cell/number-cell.js";
+import { BooleanCell as S } from "./cell/boolean-cell.js";
+import "react";
+import { cn as b } from "../../../lib/utils.js";
+const E = ({
+  value: o,
+  cellType: m,
+  cellRenderer: n,
+  record: f,
+  index: i,
+  customCells: e,
+  cell: C
+}) => {
+  const c = {
+    text: p,
+    number: h,
+    boolean: S
+  }, s = e == null ? void 0 : e[m];
+  let t;
+  if (n)
+    t = n({ value: o, record: f, index: i });
+  else if (s)
+    t = /* @__PURE__ */ l(s, { value: o, record: f, index: i });
+  else {
+    const a = c[m] ?? p;
+    t = /* @__PURE__ */ l(a, { value: o });
+  }
+  return /* @__PURE__ */ l(
+    "td",
+    {
+      className: b(
+        r.cell.default,
+        r.cell.cellHeight[C.cellHeight],
+        r.cell.hasBorder[C.hasBorder ? "true" : "false"]
+      ),
+      children: t
+    }
+  );
+};
+export {
+  E as TableCell
+};

package/dist/components/table/components/table-empty-state.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface TableEmptyStateProps {
+    colSpan: number;
+    message: string;
+}
+export declare const TableEmptyState: React.FC<TableEmptyStateProps>;
+export {};

package/dist/components/table/components/table-empty-state.js

@@ -0,0 +1,6 @@
+import { jsx as t } from "react/jsx-runtime";
+import { TABLE_CSS_CLASSES as m } from "../table.const.js";
+const a = ({ colSpan: r, message: e }) => /* @__PURE__ */ t("tbody", { children: /* @__PURE__ */ t("tr", { children: /* @__PURE__ */ t("td", { colSpan: r, className: m.emptyState, children: e }) }) });
+export {
+  a as TableEmptyState
+};

package/dist/components/table/components/table-filter/filters/boolean.d.ts

@@ -0,0 +1,3 @@
+import { FilterComponentType } from '../table-filter.type';
+declare const BooleanFilter: FilterComponentType;
+export default BooleanFilter;

package/dist/components/table/components/table-filter/filters/boolean.js

@@ -0,0 +1,31 @@
+import { jsxs as a, Fragment as n, jsx as t } from "react/jsx-runtime";
+import { useEffect as u } from "react";
+const o = ["equals", "notEqual"], s = ({ value: r, onChange: l }) => (u(() => {
+  r.condition || l({ condition: o[0] });
+}, []), /* @__PURE__ */ a(n, { children: [
+  /* @__PURE__ */ t(
+    "select",
+    {
+      value: r.condition,
+      onChange: (e) => l({ condition: e.target.value }),
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary rounded px-2 py-1 text-sm",
+      children: o.map((e) => /* @__PURE__ */ t("option", { value: e, children: e }, e))
+    }
+  ),
+  /* @__PURE__ */ a(
+    "select",
+    {
+      value: r.value,
+      onChange: (e) => l({ value: e.target.value }),
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary rounded px-2 py-1 text-sm flex-1",
+      children: [
+        /* @__PURE__ */ t("option", { value: "", children: "Select value" }),
+        /* @__PURE__ */ t("option", { value: "true", children: "True" }),
+        /* @__PURE__ */ t("option", { value: "false", children: "False" })
+      ]
+    }
+  )
+] }));
+export {
+  s as default
+};

package/dist/components/table/components/table-filter/filters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './text';
+export * from './boolean';
+export * from './number';

package/dist/components/table/components/table-filter/filters/number.d.ts

@@ -0,0 +1,3 @@
+import { FilterComponentType } from '../table-filter.type';
+declare const NumberFilter: FilterComponentType;
+export default NumberFilter;

package/dist/components/table/components/table-filter/filters/number.js

@@ -0,0 +1,28 @@
+import { jsxs as o, Fragment as u, jsx as a } from "react/jsx-runtime";
+import { useEffect as d } from "react";
+const l = [">", "<", "=", "!="], s = ({ value: t, onChange: r }) => (d(() => {
+  t.condition || r({ condition: l[0] });
+}, []), /* @__PURE__ */ o(u, { children: [
+  /* @__PURE__ */ a(
+    "select",
+    {
+      value: t.condition,
+      onChange: (e) => r({ condition: e.target.value }),
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary rounded px-2 py-1 text-sm",
+      children: l.map((e) => /* @__PURE__ */ a("option", { value: e, children: e }, e))
+    }
+  ),
+  /* @__PURE__ */ a(
+    "input",
+    {
+      type: "number",
+      value: t.value,
+      onChange: (e) => r({ value: e.target.value }),
+      placeholder: "Value",
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary placeholder:text-text-neutral-muted rounded px-2 py-1 text-sm flex-1"
+    }
+  )
+] }));
+export {
+  s as default
+};

package/dist/components/table/components/table-filter/filters/text.d.ts

@@ -0,0 +1,3 @@
+import { FilterComponentType } from '../table-filter.type';
+declare const TextFilter: FilterComponentType;
+export default TextFilter;

package/dist/components/table/components/table-filter/filters/text.js

@@ -0,0 +1,28 @@
+import { jsxs as o, Fragment as u, jsx as a } from "react/jsx-runtime";
+import { useEffect as n } from "react";
+const l = ["contains", "notEqual", "equals"], i = ({ value: t, onChange: r }) => (n(() => {
+  t.condition || r({ condition: l[0] });
+}, []), /* @__PURE__ */ o(u, { children: [
+  /* @__PURE__ */ a(
+    "select",
+    {
+      value: t.condition,
+      onChange: (e) => r({ condition: e.target.value }),
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary rounded px-2 py-1 text-sm",
+      children: l.map((e) => /* @__PURE__ */ a("option", { value: e, children: e }, e))
+    }
+  ),
+  /* @__PURE__ */ a(
+    "input",
+    {
+      type: "text",
+      value: t.value,
+      onChange: (e) => r({ value: e.target.value }),
+      placeholder: "Value",
+      className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary placeholder:text-text-neutral-muted rounded px-2 py-1 text-sm flex-1"
+    }
+  )
+] }));
+export {
+  i as default
+};

package/dist/components/table/components/table-filter/index.d.ts

@@ -0,0 +1 @@
+export { TableFilter } from './table-filter';

package/dist/components/table/components/table-filter/table-filter.d.ts

@@ -0,0 +1,9 @@
+import { FilterComponentType } from './table-filter.type';
+import { TableSchema, TableFilter as TableFilterType } from '../../table.type';
+import * as React from 'react';
+export interface TableFilterProps {
+    filterComponents?: Record<string, FilterComponentType>;
+    schema: TableSchema;
+    filter?: TableFilterType;
+}
+export declare const TableFilter: React.FC<TableFilterProps>;

package/dist/components/table/components/table-filter/table-filter.hook.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { TableFilterProps } from './table-filter.type';
+import { FilterRule } from '../../table.type';
+declare const useTableFilter: ({ filter, schema }: TableFilterProps) => {
+    isOpen: boolean;
+    addFilterRule: () => void;
+    updateFilterRule: (index: number, updates: Partial<FilterRule>) => void;
+    removeFilterRule: (index: number) => void;
+    applyFilters: () => void;
+    hasActiveFilters: boolean;
+    setIsOpen: React.Dispatch<React.SetStateAction<boolean>>;
+    tempFilters: FilterRule[];
+    filterableFields: import('../../table.type').TableSchemaColumn[];
+};
+export default useTableFilter;

package/dist/components/table/components/table-filter/table-filter.hook.js

@@ -0,0 +1,34 @@
+import u from "react";
+const h = ({ filter: t, schema: r }) => {
+  const [p, o] = u.useState(!1), [s, a] = u.useState(t.value), c = r.filter((e) => e.filterable !== !1), d = () => {
+    var l;
+    const e = {
+      field: ((l = c[0]) == null ? void 0 : l.key) || "",
+      value: ""
+    };
+    a([...s, e]);
+  }, f = (e, l) => {
+    const n = s.map((i, R) => R === e ? { ...i, ...l } : i);
+    a(n);
+  }, F = (e) => {
+    a(s.filter((l, n) => n !== e));
+  }, v = () => {
+    t.onChange(s), o(!1);
+  }, m = t.value.length > 0;
+  return u.useEffect(() => {
+    a(t.value);
+  }, [t.value]), {
+    isOpen: p,
+    addFilterRule: d,
+    updateFilterRule: f,
+    removeFilterRule: F,
+    applyFilters: v,
+    hasActiveFilters: m,
+    setIsOpen: o,
+    tempFilters: s,
+    filterableFields: c
+  };
+};
+export {
+  h as default
+};

package/dist/components/table/components/table-filter/table-filter.js

@@ -0,0 +1,105 @@
+import { jsxs as r, jsx as t } from "react/jsx-runtime";
+import { Button as s } from "../../../button/button.js";
+import N from "./table-filter.hook.js";
+import T from "./filters/text.js";
+import z from "./filters/boolean.js";
+import w from "./filters/number.js";
+const C = ({
+  filterComponents: o = {},
+  schema: c,
+  filter: n
+}) => {
+  const {
+    addFilterRule: b,
+    applyFilters: y,
+    filterableFields: k,
+    hasActiveFilters: d,
+    isOpen: m,
+    removeFilterRule: F,
+    setIsOpen: p,
+    tempFilters: x,
+    updateFilterRule: u
+  } = N({ schema: c, filter: n || { value: [], onChange: () => {
+  } } });
+  return n ? /* @__PURE__ */ r("div", { className: "relative mb-4", children: [
+    /* @__PURE__ */ r(
+      s,
+      {
+        onClick: () => p(!m),
+        variant: d ? "filled" : "stroke",
+        shade: d ? "brand" : "neutral",
+        size: "small",
+        children: [
+          "Filter ",
+          d && `(${n.value.length})`
+        ]
+      }
+    ),
+    m && /* @__PURE__ */ t("div", { className: "absolute top-full left-0 mt-2 min-w-96 bg-surface-neutral-default border border-stroke-solid-medium rounded-md shadow-default z-10 p-4", children: /* @__PURE__ */ r("div", { className: "space-y-4", children: [
+      x.map((i, a) => {
+        const e = c.find((l) => l.key === i.field), h = {
+          boolean: z,
+          text: T,
+          number: w
+        }, v = (o == null ? void 0 : o[(e == null ? void 0 : e.cellType) || ""]) || h[(e == null ? void 0 : e.cellType) || "text"];
+        v || console.warn(
+          `No filter component found for column "${e == null ? void 0 : e.key}" with cellType "${e == null ? void 0 : e.cellType}". Provide a custom filter component or use supported types: "text", "number", "boolean".`
+        );
+        const g = v ?? h.text;
+        return /* @__PURE__ */ r("div", { className: "flex gap-2 items-center", children: [
+          /* @__PURE__ */ t(
+            "select",
+            {
+              value: i.field,
+              onChange: (l) => u(a, { field: l.target.value, condition: void 0 }),
+              className: "border border-stroke-solid-medium bg-surface-neutral-default text-text-neutral-primary rounded px-2 py-1 text-sm flex-1",
+              children: k.map((l) => /* @__PURE__ */ t("option", { value: l.key, children: l.title }, l.key))
+            }
+          ),
+          /* @__PURE__ */ t(
+            g,
+            {
+              onChange: ({ condition: l, value: f }) => {
+                u(a, {
+                  ...l ? { condition: l } : {},
+                  ...f ? { value: f } : {}
+                });
+              },
+              value: { value: i.value, condition: i.condition }
+            },
+            a
+          ),
+          /* @__PURE__ */ t(
+            s,
+            {
+              onClick: () => F(a),
+              variant: "ghost",
+              shade: "danger",
+              size: "small",
+              className: "!px-2 !py-1",
+              children: "×"
+            }
+          )
+        ] }, a);
+      }),
+      /* @__PURE__ */ r("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ t(s, { onClick: b, variant: "stroke", shade: "neutral", size: "small", children: "+ Add" }),
+        /* @__PURE__ */ t("div", { className: "flex-1" }),
+        /* @__PURE__ */ t(
+          s,
+          {
+            onClick: () => p(!1),
+            variant: "stroke",
+            shade: "neutral",
+            size: "small",
+            children: "Cancel"
+          }
+        ),
+        /* @__PURE__ */ t(s, { onClick: y, variant: "filled", shade: "brand", size: "small", children: "Apply" })
+      ] })
+    ] }) })
+  ] }) : null;
+};
+export {
+  C as TableFilter
+};

package/dist/components/table/components/table-filter/table-filter.type.d.ts

@@ -0,0 +1,18 @@
+import { FC } from 'react';
+import { TableFilter, TableSchema } from '../../table.type';
+export interface TableFilterProps {
+    schema: TableSchema;
+    filter: TableFilter;
+    filterComponents?: Record<string, FilterComponentType>;
+}
+export type FilterComponentProps = {
+    onChange: (input: {
+        condition?: string;
+        value?: string;
+    }) => void;
+    value: {
+        condition?: string;
+        value: string;
+    };
+};
+export type FilterComponentType = FC<FilterComponentProps>;

package/dist/components/table/components/table-footer-content.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface TableFooterContentProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const TableFooterContent: React.FC<TableFooterContentProps>;
+export default TableFooterContent;

package/dist/components/table/components/table-footer-content.js

@@ -0,0 +1,9 @@
+import { jsx as o } from "react/jsx-runtime";
+const s = ({
+  children: e,
+  className: t = ""
+}) => /* @__PURE__ */ o("div", { className: `flex items-center ${t}`, children: e });
+export {
+  s as TableFooterContent,
+  s as default
+};

package/dist/components/table/components/table-footer.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+export interface TableFooterProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const TableFooter: React.FC<TableFooterProps>;
+export default TableFooter;

package/dist/components/table/components/table-footer.js

@@ -0,0 +1,6 @@
+import { jsx as r } from "react/jsx-runtime";
+const o = ({ children: e, className: t = "" }) => /* @__PURE__ */ r("div", { className: `flex justify-between items-center ${t}`, children: e });
+export {
+  o as TableFooter,
+  o as default
+};

package/dist/components/table/components/table-header/index.d.ts

@@ -0,0 +1,2 @@
+export { TableHeader } from './table-header';
+export { TableSortIcon } from './table-sort-icon';

package/dist/components/table/components/table-header/table-header.d.ts

@@ -0,0 +1,9 @@
+import { TableSchemaColumn, TableSort, TableProps } from '../../table.type';
+import * as React from 'react';
+interface TableHeaderProps {
+    schema: TableSchemaColumn[];
+    sort?: TableSort;
+    cell: TableProps['cell'];
+}
+export declare const TableHeader: React.FC<TableHeaderProps>;
+export {};

package/dist/components/table/components/table-header/table-header.js

@@ -0,0 +1,27 @@
+import { jsx as r, jsxs as d } from "react/jsx-runtime";
+import { TABLE_CSS_CLASSES as t } from "../../table.const.js";
+import { TableSortIcon as c } from "./table-sort-icon.js";
+import { getCurrentSortDirection as n, isSortActive as h, handleSortClick as p } from "./table-header.utils.js";
+import "react";
+import { cn as C } from "../../../../lib/utils.js";
+const y = ({ schema: a, sort: i, cell: o }) => /* @__PURE__ */ r("thead", { className: t.header, children: /* @__PURE__ */ r("tr", { children: a.map((e) => {
+  const s = n(e.key, i), l = h(e.key, i);
+  return /* @__PURE__ */ r(
+    "th",
+    {
+      className: C(
+        e.sortable ? t.sortableHeaderCell : t.headerCell,
+        t.cell.hasBorder[o.hasBorder ? "true" : "false"]
+      ),
+      onClick: e.sortable ? () => p(e.key, i) : void 0,
+      children: /* @__PURE__ */ d("div", { className: t.headerCellContent, children: [
+        /* @__PURE__ */ r("span", { children: e.title }),
+        e.sortable && /* @__PURE__ */ r(c, { direction: s, isActive: l })
+      ] })
+    },
+    e.key
+  );
+}) }) });
+export {
+  y as TableHeader
+};

package/dist/components/table/components/table-header/table-header.utils.d.ts

@@ -0,0 +1,5 @@
+import { TableSort, SortDirection } from '../../table.type';
+export declare const getCurrentSortDirection: (field: string, sort?: TableSort) => SortDirection;
+export declare const getNextSortDirection: (currentDirection: SortDirection) => SortDirection;
+export declare const isSortActive: (field: string, sort?: TableSort) => boolean;
+export declare const handleSortClick: (field: string, sort?: TableSort) => void;