neatkit 0.7.0 → 0.9.0

package/dist/components/Table/components/TableActionCell.d.ts

@@ -0,0 +1,15 @@
+import { type TableRowAction } from "./TableAction";
+/** Internal action-cell properties supplied by a Table.Row. */
+export type TableActionCellProps = {
+    /** The controls rendered inside the row's action cell. */
+    actions: readonly TableRowAction[];
+};
+/**
+ * Renders the cell containing controls for one Table row.
+ *
+ * @param props - The composed Table actions operating on the row.
+ *
+ * @returns The rendered Table action cell.
+ */
+declare function TableActionCell(props: TableActionCellProps): import("react").JSX.Element;
+export default TableActionCell;

package/dist/components/Table/components/TableActionHeaderCell.d.ts

@@ -0,0 +1,13 @@
+import { type TableHeaderCellProps } from "./TableHeaderCell";
+/** A type representing properties for the Table action header cell. */
+export type TableActionHeaderCellProps = Omit<TableHeaderCellProps, "align">;
+/**
+ * Renders the header for a row-actions column.
+ *
+ * @param props - The native header properties and optional visible label.
+ * @param forwardedReference - The reference assigned to the header cell.
+ *
+ * @returns The rendered Table actions header.
+ */
+declare const TableActionHeaderCell: import("react").ForwardRefExoticComponent<TableActionHeaderCellProps & import("react").RefAttributes<HTMLTableCellElement>>;
+export default TableActionHeaderCell;

package/dist/components/Table/components/TableBody.d.ts

@@ -0,0 +1,27 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/** A type representing properties for the Table.Body component. */
+export type TableBodyProps = HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table body. */
+    children?: ReactNode;
+    /** The number of columns occupied by the generated empty-state cell. */
+    emptyColumnCount?: number;
+    /** The content displayed when children contain no explicit content. */
+    emptyMessage?: ReactNode;
+};
+/**
+ * Renders the Table body and its optional empty state.
+ *
+ * @param props - The native section, row, and empty-state properties.
+ * @param forwardedReference - The reference assigned to the body element.
+ *
+ * @returns The rendered Table body section.
+ */
+declare const TableBody: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table body. */
+    children?: ReactNode;
+    /** The number of columns occupied by the generated empty-state cell. */
+    emptyColumnCount?: number;
+    /** The content displayed when children contain no explicit content. */
+    emptyMessage?: ReactNode;
+} & import("react").RefAttributes<HTMLTableSectionElement>>;
+export default TableBody;

package/dist/components/Table/components/TableCell.d.ts

@@ -0,0 +1,42 @@
+import { type ReactNode, type TdHTMLAttributes } from "react";
+import { type TableCellAlignment, type TableCellFormatter, type TableCellValue } from "../utils/cell";
+import type { TableRowTrigger } from "../utils/trigger";
+/** A type representing properties for the Table.Cell component. */
+export type TableCellProps = Omit<TdHTMLAttributes<HTMLTableCellElement>, "align" | "children"> & {
+    /** The horizontal alignment applied to the cell content. */
+    align?: TableCellAlignment;
+    /** Content rendered when no value is supplied. */
+    children?: ReactNode;
+    /** A function transforming the supplied value into displayed content. */
+    format?: TableCellFormatter;
+    /** The maximum CSS width used to truncate overflowing content. */
+    truncate?: string;
+    /** The primitive value displayed or passed to the format function. */
+    value?: TableCellValue;
+};
+/** Internal Table.Cell properties supplied by an interactive Table.Row. */
+export type TableCellImplementationProps = TableCellProps & {
+    /** The primary row control rendered inside the first data cell. */
+    rowTrigger?: TableRowTrigger;
+};
+/**
+ * Renders a data cell with optional value formatting and truncation.
+ *
+ * @param props - The native cell, content, and display properties.
+ * @param forwardedReference - The reference assigned to the data cell.
+ *
+ * @returns The rendered Table data cell.
+ */
+declare const TableCell: import("react").ForwardRefExoticComponent<Omit<TdHTMLAttributes<HTMLTableCellElement>, "children" | "align"> & {
+    /** The horizontal alignment applied to the cell content. */
+    align?: TableCellAlignment;
+    /** Content rendered when no value is supplied. */
+    children?: ReactNode;
+    /** A function transforming the supplied value into displayed content. */
+    format?: TableCellFormatter;
+    /** The maximum CSS width used to truncate overflowing content. */
+    truncate?: string;
+    /** The primitive value displayed or passed to the format function. */
+    value?: TableCellValue;
+} & import("react").RefAttributes<HTMLTableCellElement>>;
+export default TableCell;

package/dist/components/Table/components/TableFoot.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/** A type representing properties for the Table.Foot component. */
+export type TableFootProps = HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table foot. */
+    children: ReactNode;
+};
+/**
+ * Renders the Table foot section.
+ *
+ * @param props - The native section properties and footer rows.
+ * @param forwardedReference - The reference assigned to the foot element.
+ *
+ * @returns The rendered Table foot section.
+ */
+declare const TableFoot: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table foot. */
+    children: ReactNode;
+} & import("react").RefAttributes<HTMLTableSectionElement>>;
+export default TableFoot;

package/dist/components/Table/components/TableHead.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+/** A type representing properties for the Table.Head component. */
+export type TableHeadProps = HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table head. */
+    children: ReactNode;
+};
+/**
+ * Renders the Table head section.
+ *
+ * @param props - The native section properties and header rows.
+ * @param forwardedReference - The reference assigned to the head element.
+ *
+ * @returns The rendered Table head section.
+ */
+declare const TableHead: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
+    /** The rows rendered inside the Table head. */
+    children: ReactNode;
+} & import("react").RefAttributes<HTMLTableSectionElement>>;
+export default TableHead;

package/dist/components/Table/components/TableHeaderCell.d.ts

@@ -0,0 +1,23 @@
+import { type ReactNode, type ThHTMLAttributes } from "react";
+import type { TableCellAlignment } from "../utils/cell";
+/** Shared properties configuring a Table header cell. */
+type TableHeaderCellOwnProps = {
+    /** The horizontal alignment applied to the header content. */
+    align?: TableCellAlignment;
+    /** The content rendered inside the header cell. */
+    children?: ReactNode;
+    /** Whether the header pins its supported edge column during scrolling. */
+    sticky?: boolean;
+};
+/** A type representing properties for the Table.HeaderCell component. */
+export type TableHeaderCellProps = Omit<ThHTMLAttributes<HTMLTableCellElement>, "align" | "children"> & TableHeaderCellOwnProps;
+/**
+ * Renders a column header cell.
+ *
+ * @param props - The native header properties and displayed label.
+ * @param forwardedReference - The reference assigned to the header cell.
+ *
+ * @returns The rendered Table column header.
+ */
+declare const TableHeaderCell: import("react").ForwardRefExoticComponent<Omit<ThHTMLAttributes<HTMLTableCellElement>, "children" | "align"> & TableHeaderCellOwnProps & import("react").RefAttributes<HTMLTableCellElement>>;
+export default TableHeaderCell;

package/dist/components/Table/components/TableRow.d.ts

@@ -0,0 +1,67 @@
+import { type HTMLAttributes, type MouseEventHandler, type ReactNode } from "react";
+import { type TableRowLinkProperties } from "../utils/trigger";
+import type { TableRowAction } from "./TableAction";
+/** Shared native properties for every Table.Row configuration. */
+type TableRowBaseProps = Omit<HTMLAttributes<HTMLTableRowElement>, "aria-label" | "children" | "onClick"> & {
+    /**
+     * The controls operating on this row.
+     *
+     * Each action is keyed by its label, so labels must be unique per row.
+     */
+    actions?: readonly TableRowAction[];
+    /** The cells rendered inside the Table row. */
+    children: ReactNode;
+};
+/** A type representing a static Table.Row configuration. */
+type TableStaticRowProps = {
+    /** The optional accessible name applied to the static row. */
+    "aria-label"?: string;
+    /** Static rows do not expose download behavior. */
+    download?: never;
+    /** Static rows do not expose a navigation destination. */
+    href?: never;
+    /** Static rows do not describe a linked resource language. */
+    hrefLang?: never;
+    /** Static rows do not expose whole-row activation. */
+    onClick?: never;
+    /** Static rows do not expose navigation interception. */
+    onNavigate?: never;
+    /** Static rows do not target a browsing context. */
+    target?: never;
+};
+/** A type representing a button-backed Table.Row configuration. */
+type TableButtonRowProps = {
+    /** The accessible name describing the whole-row action. */
+    "aria-label": string;
+    /** Button-backed rows do not expose download behavior. */
+    download?: never;
+    /** Button-backed rows do not expose a navigation destination. */
+    href?: never;
+    /** Button-backed rows do not describe a linked resource language. */
+    hrefLang?: never;
+    /** The callback invoked when the row's button is activated. */
+    onClick: MouseEventHandler<HTMLButtonElement>;
+    /** Button-backed rows do not expose navigation interception. */
+    onNavigate?: never;
+    /** Button-backed rows do not target a browsing context. */
+    target?: never;
+};
+/** A type representing a link-backed Table.Row configuration. */
+type TableLinkRowProps = TableRowLinkProperties & {
+    /** The accessible name describing the whole-row link. */
+    "aria-label": string;
+    /** Link-backed rows do not expose button activation. */
+    onClick?: never;
+};
+/** A type representing properties for the Table.Row component. */
+export type TableRowProps = TableRowBaseProps & (TableButtonRowProps | TableLinkRowProps | TableStaticRowProps);
+/**
+ * Renders a native Table row without replacing its table semantics.
+ *
+ * @param props - The native row properties and cells.
+ * @param forwardedReference - The reference assigned to the row element.
+ *
+ * @returns The rendered Table row.
+ */
+declare const TableRow: import("react").ForwardRefExoticComponent<TableRowProps & import("react").RefAttributes<HTMLTableRowElement>>;
+export default TableRow;

package/dist/components/Table/contexts/TableContext.d.ts

@@ -0,0 +1,4 @@
+/** A type representing the section a Table row belongs to. */
+export type TableSection = "head" | "body" | "foot";
+/** The internal context naming the section a row is rendered inside. */
+export declare const TableSectionContext: import("react").Context<TableSection>;

package/dist/components/Table/hooks/useHorizontalOverflow.d.ts

@@ -0,0 +1,25 @@
+import { type MutableRefObject, type UIEvent } from "react";
+/** A type representing the tracked horizontal overflow of a scroll region. */
+export type HorizontalOverflow = {
+    /** The reference assigned to the scrolling container. */
+    containerReference: MutableRefObject<HTMLDivElement | null>;
+    /** The reference assigned to the content measured for overflow. */
+    contentReference: MutableRefObject<HTMLElement | null>;
+    /** Whether the content currently overflows its container horizontally. */
+    isScrollable: boolean;
+    /** Whether the container is scrolled away from its inline start. */
+    isScrolled: boolean;
+    /** Records the scroll position reached by the container. */
+    handleScroll: (event: UIEvent<HTMLDivElement>) => void;
+};
+/**
+ * Tracks whether a container's content overflows it horizontally.
+ *
+ * Overflow is measured rather than assumed, so a scroll region only becomes
+ * focusable while there is content a keyboard user cannot otherwise reach.
+ *
+ * @note Falls back to resize events when `ResizeObserver` is unavailable.
+ *
+ * @returns The element references, overflow state, and scroll handler.
+ */
+export declare function useHorizontalOverflow(): HorizontalOverflow;

package/dist/components/Table/index.d.ts

@@ -1,2 +1,2 @@
 export { default } from "./Table";
-export type { TableActionCellProps, TableActionHeaderCellProps, TableActionProps, TableBodyProps, TableCellAlignment, TableCellProps, TableCellValue, TableFootProps, TableHeaderCellProps, TableHeadProps, TableProps, TableRowProps, } from "./Table";
+export type { TableBodyProps, TableCellAlignment, TableCellProps, TableCellValue, TableFootProps, TableHeaderCellProps, TableHeadProps, TableProps, TableRowAction, TableRowProps, } from "./Table";

package/dist/components/Table/utils/cell.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from "react";
+/** A value rendered directly or formatted by a Table cell. */
+export type TableCellValue = boolean | Date | number | string;
+/** The horizontal alignment applied to Table cell content. */
+export type TableCellAlignment = "left" | "center" | "right";
+/** A function transforming a supplied value into displayed cell content. */
+export type TableCellFormatter = (value: TableCellValue) => ReactNode;
+/**
+ * Resolves the content displayed for a Table cell value.
+ *
+ * @param value - The supplied cell value.
+ * @param children - The fallback content used when no value is supplied.
+ * @param format - The optional consumer formatter applied to the value.
+ *
+ * @returns The content displayed inside the Table cell.
+ */
+export declare function resolveCellContent(value: TableCellValue | undefined, children: ReactNode, format: TableCellFormatter | undefined): ReactNode;
+/**
+ * Resolves a native title for truncated primitive content.
+ *
+ * @param content - The rendered content considered for a title.
+ *
+ * @returns A readable title, when the content can be represented as text.
+ */
+export declare function resolveTruncateTitle(content: ReactNode): string | undefined;

package/dist/components/Table/utils/children.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+/**
+ * Determines whether Table body children contain explicit content.
+ *
+ * Empty Fragments are inspected recursively. Components are considered
+ * content because their eventual render output cannot be known by the parent.
+ *
+ * @param content - The Table body children inspected for content.
+ *
+ * @returns Whether the children contain a non-empty explicit child.
+ */
+export declare function hasTableBodyContent(content: ReactNode): boolean;
+/**
+ * Warns when a sticky Table header is placed outside its supported edge.
+ *
+ * @param content - The cells rendered inside one Table row.
+ */
+export declare function warnAboutInvalidStickyHeaders(content: ReactNode): void;

package/dist/components/Table/utils/trigger.d.ts

@@ -0,0 +1,54 @@
+import { type HTMLAttributeAnchorTarget, type MouseEventHandler, type ReactNode } from "react";
+/** The navigation properties describing a link-backed Table row. */
+export type TableRowLinkProperties = {
+    /** Whether the linked resource should be downloaded. */
+    download?: boolean | string;
+    /** The destination opened by whole-row activation. */
+    href: string;
+    /** The language of the linked resource. */
+    hrefLang?: string;
+    /** The callback invoked when the row's link is activated. */
+    onNavigate?: MouseEventHandler<HTMLAnchorElement>;
+    /** The relationship between the table and linked resource. */
+    rel?: string;
+    /** The browsing context used to open the linked resource. */
+    target?: HTMLAttributeAnchorTarget;
+};
+/** A type representing the primary control injected into a Table row. */
+export type TableRowTrigger = {
+    /** The accessible name describing the row activation. */
+    ariaLabel: string;
+    /** Whether the primary control uses link or button semantics. */
+    kind: "button" | "link";
+    /** Assigns the rendered primary control to its owning row. */
+    reference: (element: HTMLAnchorElement | HTMLButtonElement | null) => void;
+    /** The link-backed row properties, when navigation is configured. */
+    linkProperties?: TableRowLinkProperties;
+    /** The button activation callback, when an action is configured. */
+    onClick?: MouseEventHandler<HTMLButtonElement>;
+};
+/** A type representing the outcome of injecting a row's primary control. */
+export type TableRowTriggerAttachment = {
+    /** Whether a data cell was available to receive the control. */
+    attached: boolean;
+    /** The row content containing the injected control, when one was found. */
+    content: ReactNode;
+};
+/**
+ * Determines whether a click originated from a nested interactive descendant.
+ *
+ * @param target - The deepest element receiving the click.
+ * @param row - The row limiting ancestor inspection.
+ *
+ * @returns Whether a nested native or ARIA widget owns the interaction.
+ */
+export declare function isInteractiveRowDescendant(target: Element, row: HTMLTableRowElement): boolean;
+/**
+ * Injects a row's semantic trigger into its first explicit data cell.
+ *
+ * @param content - The row cells inspected recursively.
+ * @param trigger - The link or button representing whole-row activation.
+ *
+ * @returns The row content containing one primary control.
+ */
+export declare function attachRowTrigger(content: ReactNode, trigger: TableRowTrigger): TableRowTriggerAttachment;

package/dist/components/Tooltip/Tooltip.d.ts

@@ -1,5 +1,6 @@
 import { type CSSProperties, type ReactElement, type ReactNode } from "react";
 import type { FloatingPlacement } from "../Portal/utils/floating-position";
+import TooltipProvider from "./TooltipProvider";
 import "./styles/tooltip.css";
 /** A type representing the preferred placement of a Tooltip. */
 export type TooltipPlacement = FloatingPlacement;
@@ -30,10 +31,8 @@ export type TooltipProps = {
     disabled?: boolean;
     /** The callback invoked whenever the Tooltip opens or closes. */
     onOpenChange?: (open: boolean) => void;
-    /** The preferred placement before viewport collision handling. */
+    /** The preferred placement before collision handling. */
     placement?: TooltipPlacement;
-    /** The optional element receiving the Tooltip portal. */
-    portalContainer?: Element | null;
     /** The inline styles applied to the trigger element. */
     style?: CSSProperties;
 };
@@ -50,5 +49,12 @@ export type TooltipProps = {
  *
  * @returns The trigger and its portal-backed Tooltip description.
  */
-declare const Tooltip: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLElement>>;
+declare const TooltipRoot: import("react").ForwardRefExoticComponent<TooltipProps & import("react").RefAttributes<HTMLElement>>;
+/** A type representing the complete compound Tooltip component. */
+type TooltipComponent = typeof TooltipRoot & {
+    /** The provider supplying shared behavior to descendant Tooltips. */
+    Provider: typeof TooltipProvider;
+};
+/** The compound Tooltip component and its shared-behavior provider. */
+declare const Tooltip: TooltipComponent;
 export default Tooltip;

package/dist/components/Tooltip/TooltipProvider.d.ts

@@ -6,7 +6,7 @@ type TooltipContextValue = {
 };
 /** Shared Tooltip behavior remains optional for standalone usage. */
 export declare const TooltipContext: import("react").Context<TooltipContextValue | null>;
-/** A type representing properties for the TooltipProvider component. */
+/** A type representing properties for the Tooltip.Provider component. */
 export type TooltipProviderProps = {
     /** The Tooltip-bearing interface receiving shared behavior. */
     children: ReactNode;

package/dist/components/Tooltip/index.d.ts

@@ -1,4 +1,3 @@
 export { default } from "./Tooltip";
 export type { TooltipPlacement, TooltipProps } from "./Tooltip";
-export { default as TooltipProvider } from "./TooltipProvider";
 export type { TooltipProviderProps } from "./TooltipProvider";

package/dist/effects-D5CWf-Pl.js

@@ -0,0 +1,8 @@
+import { createContext as o, useEffect as t, useLayoutEffect as e } from "react";
+const n = o(
+  void 0
+), s = typeof window > "u" ? t : e;
+export {
+  n as B,
+  s as u
+};

package/dist/effects-D85L_7zM.cjs

@@ -0,0 +1 @@
+"use strict";const t=require("react"),e=t.createContext(void 0),o=typeof window>"u"?t.useEffect:t.useLayoutEffect;exports.BoundaryContext=e;exports.useIsomorphicLayoutEffect=o;

package/dist/floating-position-DIjh2wnP.cjs

@@ -0,0 +1 @@
+"use strict";const T={bottom:"top",left:"right",right:"left",top:"bottom"};function x(h,i){const t=Math.min(12,i/2);return Math.min(Math.max(t,h),i-t)}function E(h){return T[h]}function _(h,i){return i==="left"||i==="right"?h.width:h.height}function A(h,i,t){const e=Math.max(h.left,0),o=Math.max(h.top,0),l=Math.min(h.right,i),M=Math.min(h.bottom,t);return l<=e||M<=o?h:{bottom:M,left:e,right:l,top:o}}function F(h,i,t,e,o){const l={bottom:o.bottom-t.bottom-i*2,left:t.left-o.left-i*2,right:o.right-t.right-i*2,top:t.top-o.top-i*2},M=E(h),P=_(e,h),f=l[h]<P&&l[M]>l[h]?M:h;let m=t.left+(t.width-e.width)/2,c=t.top+(t.height-e.height)/2;f==="top"?c=t.top-e.height-i:f==="bottom"?c=t.bottom+i:f==="left"?m=t.left-e.width-i:m=t.right+i;const w=o.left+i,O=o.top+i;m=Math.min(Math.max(w,m),Math.max(w,o.right-i-e.width)),c=Math.min(Math.max(O,c),Math.max(O,o.bottom-i-e.height));let a;return f==="top"||f==="bottom"?a=x(t.left+t.width/2-m,e.width):a=x(t.top+t.height/2-c,e.height),{arrowOffset:a,left:m,placement:f,top:c}}exports.calculateFloatingPosition=F;exports.getVisibleBounds=A;

package/dist/floating-position-DvR6e334.js

@@ -0,0 +1,50 @@
+const E = {
+  bottom: "top",
+  left: "right",
+  right: "left",
+  top: "bottom"
+};
+function x(i, h) {
+  const t = Math.min(12, h / 2);
+  return Math.min(Math.max(t, i), h - t);
+}
+function P(i) {
+  return E[i];
+}
+function _(i, h) {
+  return h === "left" || h === "right" ? i.width : i.height;
+}
+function p(i, h, t) {
+  const e = Math.max(i.left, 0), f = Math.max(i.top, 0), o = Math.min(i.right, h), M = Math.min(i.bottom, t);
+  return o <= e || M <= f ? i : { bottom: M, left: e, right: o, top: f };
+}
+function F(i, h, t, e, f) {
+  const o = {
+    bottom: f.bottom - t.bottom - h * 2,
+    left: t.left - f.left - h * 2,
+    right: f.right - t.right - h * 2,
+    top: t.top - f.top - h * 2
+  }, M = P(i), T = _(e, i), m = o[i] < T && o[M] > o[i] ? M : i;
+  let l = t.left + (t.width - e.width) / 2, c = t.top + (t.height - e.height) / 2;
+  m === "top" ? c = t.top - e.height - h : m === "bottom" ? c = t.bottom + h : m === "left" ? l = t.left - e.width - h : l = t.right + h;
+  const O = f.left + h, a = f.top + h;
+  l = Math.min(
+    Math.max(O, l),
+    Math.max(O, f.right - h - e.width)
+  ), c = Math.min(
+    Math.max(a, c),
+    Math.max(a, f.bottom - h - e.height)
+  );
+  let w;
+  return m === "top" || m === "bottom" ? w = x(
+    t.left + t.width / 2 - l,
+    e.width
+  ) : w = x(
+    t.top + t.height / 2 - c,
+    e.height
+  ), { arrowOffset: w, left: l, placement: m, top: c };
+}
+export {
+  F as c,
+  p as g
+};