@lucasbernardosn/react-table 0.0.0-stage → 0.2.0

package/dist/components/data-table/toolbar/data-table-sort-direction-select.d.ts

@@ -0,0 +1,40 @@
+import { TableWith } from "../../../types/table-with.js";
+import "../../../types/index.js";
+import { RowData, SortDirection, TableFeatures } from "@tanstack/react-table";
+import { Select } from "@lucasbernardosn/react-ui/collections/select";
+import { MergeOverride } from "@lucasbernardosn/utils";
+//#region src/components/data-table/toolbar/data-table-sort-direction-select.d.ts
+export type DataTableSortDirectionSelectProps<TFeatures extends TableFeatures, TData extends RowData> = MergeOverride<Select.TriggerProps, {
+  /** A tabela. Exige `rowSortingFeature`. */
+  table: TableWith<TFeatures, TData, 'rowSortingFeature'>;
+  /**
+   * O nome de cada direção.
+   * @default { asc: 'Crescente', desc: 'Decrescente' }
+   */
+  labels?: Partial<Record<SortDirection, string>>;
+  /**
+   * O tamanho do select.
+   * @default 'sm'
+   */
+  size?: Select.RootProps<SortDirection>['size'];
+}>;
+/**
+ * O select da direção da ordenação, para ir junto com o `DataTable.SortColumnSelect`. Troca a
+ * direção da primeira coluna da ordenação; sem ordenação, fica desabilitado.
+ *
+ * Renderiza o `Select` do `ui` por dentro; as props passam para o trigger.
+ *
+ * @example
+ * ```tsx
+ * <DataTable.SortDirectionSelect
+ *   table={table}
+ *   labels={{ asc: 'A–Z', desc: 'Z–A' }}
+ * />
+ * ```
+ */
+export declare const DataTableSortDirectionSelect: {
+  <TFeatures extends TableFeatures, TData extends RowData>(props: DataTableSortDirectionSelectProps<TFeatures, TData>): import("react").JSX.Element;
+  displayName: string;
+};
+//#endregion
+//# sourceMappingURL=data-table-sort-direction-select.d.ts.map

package/dist/components/data-table/toolbar/data-table-sort-direction-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-sort-direction-select.d.ts","names":[],"sources":["../../../../src/components/data-table/toolbar/data-table-sort-direction-select.tsx"],"mappings":";;;;;;YAUY,kCACV,kBAAkB,eAClB,cAAc,WACZ,cACF,OAAO;;EAGL,OAAO,UAAU,WAAW;;;;;EAK5B,SAAS,QAAQ,OAAO;;;;;EAKxB,OAAO,OAAO,UAAU;;;;;;;;;;;;;;;;qBAyBf;GACX,kBAAkB,eAClB,cAAc,SAAO,OAEd,kCAAkC,WAAW,yBAAM,IAAA"}

package/dist/components/data-table/toolbar/data-table-sort-direction-select.js

@@ -0,0 +1,66 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useSelector } from "@tanstack/react-store";
+import { Select } from "@lucasbernardosn/react-ui/collections/select";
+//#region src/components/data-table/toolbar/data-table-sort-direction-select.tsx
+const DEFAULT_LABELS = {
+	asc: "Crescente",
+	desc: "Decrescente"
+};
+const DIRECTIONS = ["asc", "desc"];
+/**
+* O select da direção da ordenação, para ir junto com o `DataTable.SortColumnSelect`. Troca a
+* direção da primeira coluna da ordenação; sem ordenação, fica desabilitado.
+*
+* Renderiza o `Select` do `ui` por dentro; as props passam para o trigger.
+*
+* @example
+* ```tsx
+* <DataTable.SortDirectionSelect
+*   table={table}
+*   labels={{ asc: 'A–Z', desc: 'Z–A' }}
+* />
+* ```
+*/
+const DataTableSortDirectionSelect = (props) => {
+	const { table, labels, size = "sm", disabled, ...rest } = props;
+	/**
+	* A direção da primeira coluna da ordenação, ou `null` sem ordenação. Re-renderiza quando
+	* muda.
+	*/
+	const direction = useSelector(table.atoms.sorting, (sorting) => sorting[0] ? sorting[0].desc ? "desc" : "asc" : null);
+	const items = DIRECTIONS.map((value) => ({
+		label: labels?.[value] ?? DEFAULT_LABELS[value],
+		value
+	}));
+	/** Sem ordenação, o trigger mostra a crescente, desabilitado, para não ficar vazio. */
+	const placeholder = labels?.asc ?? DEFAULT_LABELS.asc;
+	return /* @__PURE__ */ jsxs(Select.Root, {
+		size,
+		value: direction,
+		items,
+		disabled: disabled || direction === null,
+		onValueChange: (value) => {
+			if (value !== null) table.setSorting(([first, ...others]) => first ? [{
+				...first,
+				desc: value === "desc"
+			}, ...others] : []);
+		},
+		children: [/* @__PURE__ */ jsxs(Select.Trigger, {
+			"data-component": "DataTable.SortDirectionSelect",
+			"aria-label": "Direção da ordenação",
+			...rest,
+			children: [/* @__PURE__ */ jsx(Select.Value, { placeholder }), /* @__PURE__ */ jsx(Select.Icon, {})]
+		}), /* @__PURE__ */ jsx(Select.Portal, { children: /* @__PURE__ */ jsx(Select.Positioner, {
+			alignItemWithTrigger: false,
+			children: /* @__PURE__ */ jsx(Select.Popup, { children: /* @__PURE__ */ jsx(Select.List, { children: items.map((item) => /* @__PURE__ */ jsxs(Select.Item, {
+				value: item.value,
+				children: [/* @__PURE__ */ jsx(Select.ItemIndicator, {}), /* @__PURE__ */ jsx(Select.ItemText, { children: item.label })]
+			}, item.value)) }) })
+		}) })]
+	});
+};
+DataTableSortDirectionSelect.displayName = "DataTable.SortDirectionSelect";
+//#endregion
+export { DataTableSortDirectionSelect };
+
+//# sourceMappingURL=data-table-sort-direction-select.js.map

package/dist/components/data-table/toolbar/data-table-sort-direction-select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-table-sort-direction-select.js","names":[],"sources":["../../../../src/components/data-table/toolbar/data-table-sort-direction-select.tsx"],"sourcesContent":["import { Select } from '@lucasbernardosn/react-ui/collections/select';\nimport type { MergeOverride } from '@lucasbernardosn/utils';\nimport { useSelector } from '@tanstack/react-store';\nimport type {\n  RowData,\n  SortDirection,\n  TableFeatures,\n} from '@tanstack/react-table';\nimport type { TableWith } from '../../../types';\n\nexport type DataTableSortDirectionSelectProps<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> = MergeOverride<\n  Select.TriggerProps,\n  {\n    /** A tabela. Exige `rowSortingFeature`. */\n    table: TableWith<TFeatures, TData, 'rowSortingFeature'>;\n    /**\n     * O nome de cada direção.\n     * @default { asc: 'Crescente', desc: 'Decrescente' }\n     */\n    labels?: Partial<Record<SortDirection, string>>;\n    /**\n     * O tamanho do select.\n     * @default 'sm'\n     */\n    size?: Select.RootProps<SortDirection>['size'];\n  }\n>;\n\nconst DEFAULT_LABELS: Record<SortDirection, string> = {\n  asc: 'Crescente',\n  desc: 'Decrescente',\n};\n\nconst DIRECTIONS: SortDirection[] = ['asc', 'desc'];\n\n/**\n * O select da direção da ordenação, para ir junto com o `DataTable.SortColumnSelect`. Troca a\n * direção da primeira coluna da ordenação; sem ordenação, fica desabilitado.\n *\n * Renderiza o `Select` do `ui` por dentro; as props passam para o trigger.\n *\n * @example\n * ```tsx\n * <DataTable.SortDirectionSelect\n *   table={table}\n *   labels={{ asc: 'A–Z', desc: 'Z–A' }}\n * />\n * ```\n */\nexport const DataTableSortDirectionSelect = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  props: DataTableSortDirectionSelectProps<TFeatures, TData>,\n) => {\n  const { table, labels, size = 'sm', disabled, ...rest } = props;\n\n  /**\n   * A direção da primeira coluna da ordenação, ou `null` sem ordenação. Re-renderiza quando\n   * muda.\n   */\n  const direction = useSelector(\n    table.atoms.sorting,\n    (sorting): SortDirection | null =>\n      sorting[0] ? (sorting[0].desc ? 'desc' : 'asc') : null,\n  );\n\n  const items = DIRECTIONS.map((value) => ({\n    label: labels?.[value] ?? DEFAULT_LABELS[value],\n    value,\n  }));\n\n  /** Sem ordenação, o trigger mostra a crescente, desabilitado, para não ficar vazio. */\n  const placeholder = labels?.asc ?? DEFAULT_LABELS.asc;\n\n  return (\n    <Select.Root<SortDirection>\n      size={size}\n      value={direction}\n      items={items}\n      disabled={disabled || direction === null}\n      onValueChange={(value) => {\n        if (value !== null) {\n          table.setSorting(([first, ...others]) =>\n            first ? [{ ...first, desc: value === 'desc' }, ...others] : [],\n          );\n        }\n      }}\n    >\n      <Select.Trigger\n        data-component=\"DataTable.SortDirectionSelect\"\n        aria-label=\"Direção da ordenação\"\n        {...rest}\n      >\n        <Select.Value placeholder={placeholder} />\n        <Select.Icon />\n      </Select.Trigger>\n\n      <Select.Portal>\n        <Select.Positioner alignItemWithTrigger={false}>\n          <Select.Popup>\n            <Select.List>\n              {items.map((item) => (\n                <Select.Item\n                  key={item.value}\n                  value={item.value}\n                >\n                  <Select.ItemIndicator />\n                  <Select.ItemText>{item.label}</Select.ItemText>\n                </Select.Item>\n              ))}\n            </Select.List>\n          </Select.Popup>\n        </Select.Positioner>\n      </Select.Portal>\n    </Select.Root>\n  );\n};\n\nDataTableSortDirectionSelect.displayName = 'DataTable.SortDirectionSelect';\n"],"mappings":";;;;AA+BA,MAAM,iBAAgD;CACpD,KAAK;CACL,MAAM;AACR;AAEA,MAAM,aAA8B,CAAC,OAAO,MAAM;;;;;;;;;;;;;;;AAgBlD,MAAa,gCAIX,UACG;CACH,MAAM,EAAE,OAAO,QAAQ,OAAO,MAAM,UAAU,GAAG,SAAS;;;;;CAM1D,MAAM,YAAY,YAChB,MAAM,MAAM,UACX,YACC,QAAQ,KAAM,QAAQ,EAAE,CAAC,OAAO,SAAS,QAAS,IACtD;CAEA,MAAM,QAAQ,WAAW,KAAK,WAAW;EACvC,OAAO,SAAS,UAAU,eAAe;EACzC;CACF,EAAE;;CAGF,MAAM,cAAc,QAAQ,OAAO,eAAe;CAElD,OACE,qBAAC,OAAO,MAAR;EACQ;EACN,OAAO;EACA;EACP,UAAU,YAAY,cAAc;EACpC,gBAAgB,UAAU;GACxB,IAAI,UAAU,MACZ,MAAM,YAAY,CAAC,OAAO,GAAG,YAC3B,QAAQ,CAAC;IAAE,GAAG;IAAO,MAAM,UAAU;GAAO,GAAG,GAAG,MAAM,IAAI,CAAC,CAC/D;EAEJ;EAXF,UAAA,CAaE,qBAAC,OAAO,SAAR;GACE,kBAAe;GACf,cAAW;GACX,GAAI;GAHN,UAAA,CAKE,oBAAC,OAAO,OAAR,EAA2B,YAAc,CAAA,GACzC,oBAAC,OAAO,MAAR,CAAc,CAAA,CACA;EAEhB,CAAA,GAAA,oBAAC,OAAO,QAAR,EAAA,UACE,oBAAC,OAAO,YAAR;GAAmB,sBAAsB;GACvC,UAAA,oBAAC,OAAO,OAAR,EAAA,UACE,oBAAC,OAAO,MAAR,EAAA,UACG,MAAM,KAAK,SACV,qBAAC,OAAO,MAAR;IAEE,OAAO,KAAK;IAFd,UAAA,CAIE,oBAAC,OAAO,eAAR,CAAuB,CAAA,GACvB,oBAAC,OAAO,UAAR,EAAA,UAAkB,KAAK,MAAuB,CAAA,CACnC;GALN,GAAA,KAAK,KAKC,CACd,EACU,CAAA,EACD,CAAA;EACG,CAAA,EACN,CAAA,CACJ;;AAEjB;AAEA,6BAA6B,cAAc"}

package/dist/features/active-row/active-row-feature.d.ts

@@ -0,0 +1,22 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/active-row/active-row-feature.d.ts
+/**
+ * Feature do TanStack Table para a linha ativa, a do teclado. Registre com essa chave:
+ * `tableFeatures({ activeRowFeature })`.
+ *
+ * Guarda o id da linha ativa. Com ela, o `DataTable.Root` vira `role="grid"`, e as setas andam
+ * entre as `DataTable.Row`, que gravam a linha que recebe o foco, do teclado ou do clique. A
+ * linha ativa é separada da seleção.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, activeRowFeature });
+ *
+ * const table = useTable({ features, columns, data });
+ *
+ * table.getActiveRow()?.original;
+ * ```
+ */
+export declare const activeRowFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=active-row-feature.d.ts.map

package/dist/features/active-row/active-row-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-row-feature.d.ts","names":[],"sources":["../../../src/features/active-row/active-row-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAmCa,kBAAkB"}

package/dist/features/active-row/active-row-feature.js

@@ -0,0 +1,55 @@
+import { hasRowFeature, hasTableFeature } from "../../utils/has-feature.js";
+import { assignPrototypeAPIs, assignTableAPIs, makeStateUpdater, setStateSlice } from "@tanstack/react-table";
+//#region src/features/active-row/active-row-feature.ts
+/** A linha ativa de um estado inicial, ou nenhuma quando ele não traz. */
+const getInitialActiveRowId = (initialState) => initialState.activeRowId ?? null;
+/**
+* Feature do TanStack Table para a linha ativa, a do teclado. Registre com essa chave:
+* `tableFeatures({ activeRowFeature })`.
+*
+* Guarda o id da linha ativa. Com ela, o `DataTable.Root` vira `role="grid"`, e as setas andam
+* entre as `DataTable.Row`, que gravam a linha que recebe o foco, do teclado ou do clique. A
+* linha ativa é separada da seleção.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, activeRowFeature });
+*
+* const table = useTable({ features, columns, data });
+*
+* table.getActiveRow()?.original;
+* ```
+*/
+const activeRowFeature = {
+	getInitialState: (initialState) => ({
+		activeRowId: null,
+		...initialState
+	}),
+	getDefaultTableOptions: (table) => ({ onActiveRowIdChange: makeStateUpdater("activeRowId", table) }),
+	constructTableAPIs: (table) => {
+		assignTableAPIs("activeRowFeature", table, {
+			table_setActiveRowId: { fn: (updater) => setStateSlice(table, "activeRowId", updater) },
+			table_resetActiveRowId: { fn: (defaultState) => setStateSlice(table, "activeRowId", defaultState ? null : getInitialActiveRowId(table.initialState)) },
+			table_getActiveRow: { 
+			/**
+			* O guard só tipa os atoms da tabela: com a feature registrada, ele sempre passa.
+			*/
+fn: () => {
+				const activeRowId = hasTableFeature(table, "activeRowFeature") ? table.atoms.activeRowId.get() : null;
+				return activeRowId === null ? void 0 : table.getRowModel().rowsById[activeRowId];
+			} }
+		});
+	},
+	assignRowPrototype: (prototype, table) => {
+		assignPrototypeAPIs("activeRowFeature", prototype, table, { row_getIsActive: { 
+		/**
+		* O TanStack chama com a linha de uma tabela qualquer; o guard tipa o atom, e com a
+		* feature registrada sempre passa.
+		*/
+fn: (row) => hasRowFeature(row, "activeRowFeature") && row.table.atoms.activeRowId.get() === row.id } });
+	}
+};
+//#endregion
+export { activeRowFeature };
+
+//# sourceMappingURL=active-row-feature.js.map

package/dist/features/active-row/active-row-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-row-feature.js","names":[],"sources":["../../../src/features/active-row/active-row-feature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  assignTableAPIs,\n  makeStateUpdater,\n  type Row,\n  type RowData,\n  setStateSlice,\n  type TableFeature,\n  type TableFeatures,\n  type TableState_All,\n  type Updater,\n} from '@tanstack/react-table';\nimport { hasRowFeature, hasTableFeature } from '../../utils';\n\n/** A linha ativa de um estado inicial, ou nenhuma quando ele não traz. */\nconst getInitialActiveRowId = (initialState: Partial<TableState_All>) =>\n  initialState.activeRowId ?? null;\n\n/**\n * Feature do TanStack Table para a linha ativa, a do teclado. Registre com essa chave:\n * `tableFeatures({ activeRowFeature })`.\n *\n * Guarda o id da linha ativa. Com ela, o `DataTable.Root` vira `role=\"grid\"`, e as setas andam\n * entre as `DataTable.Row`, que gravam a linha que recebe o foco, do teclado ou do clique. A\n * linha ativa é separada da seleção.\n *\n * @example\n * ```ts\n * const features = tableFeatures({ columnSizingFeature, activeRowFeature });\n *\n * const table = useTable({ features, columns, data });\n *\n * table.getActiveRow()?.original;\n * ```\n */\nexport const activeRowFeature: TableFeature = {\n  getInitialState: (initialState) => ({\n    activeRowId: null,\n    ...initialState,\n  }),\n\n  getDefaultTableOptions: (table) => ({\n    onActiveRowIdChange: makeStateUpdater('activeRowId', table),\n  }),\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('activeRowFeature', table, {\n      table_setActiveRowId: {\n        fn: (updater: Updater<string | null>) =>\n          setStateSlice(table, 'activeRowId', updater),\n      },\n      table_resetActiveRowId: {\n        fn: (defaultState?: boolean) =>\n          setStateSlice(\n            table,\n            'activeRowId',\n            defaultState ? null : getInitialActiveRowId(table.initialState),\n          ),\n      },\n      table_getActiveRow: {\n        /**\n         * O guard só tipa os atoms da tabela: com a feature registrada, ele sempre passa.\n         */\n        fn: () => {\n          const activeRowId = hasTableFeature(table, 'activeRowFeature')\n            ? table.atoms.activeRowId.get()\n            : null;\n\n          return activeRowId === null\n            ? undefined\n            : table.getRowModel().rowsById[activeRowId];\n        },\n      },\n    });\n  },\n\n  assignRowPrototype: (prototype, table) => {\n    assignPrototypeAPIs('activeRowFeature', prototype, table, {\n      row_getIsActive: {\n        /**\n         * O TanStack chama com a linha de uma tabela qualquer; o guard tipa o atom, e com a\n         * feature registrada sempre passa.\n         */\n        fn: (row: Row<TableFeatures, RowData>) =>\n          hasRowFeature(row, 'activeRowFeature') &&\n          row.table.atoms.activeRowId.get() === row.id,\n      },\n    });\n  },\n};\n"],"mappings":";;;;AAeA,MAAM,yBAAyB,iBAC7B,aAAa,eAAe;;;;;;;;;;;;;;;;;;AAmB9B,MAAa,mBAAiC;CAC5C,kBAAkB,kBAAkB;EAClC,aAAa;EACb,GAAG;CACL;CAEA,yBAAyB,WAAW,EAClC,qBAAqB,iBAAiB,eAAe,KAAK,EAC5D;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,oBAAoB,OAAO;GACzC,sBAAsB,EACpB,KAAK,YACH,cAAc,OAAO,eAAe,OAAO,EAC/C;GACA,wBAAwB,EACtB,KAAK,iBACH,cACE,OACA,eACA,eAAe,OAAO,sBAAsB,MAAM,YAAY,CAChE,EACJ;GACA,oBAAoB;;;;AAIlB,UAAU;IACR,MAAM,cAAc,gBAAgB,OAAO,kBAAkB,IACzD,MAAM,MAAM,YAAY,IAAI,IAC5B;IAEJ,OAAO,gBAAgB,OACnB,KAAA,IACA,MAAM,YAAY,CAAC,CAAC,SAAS;GACnC,EACF;EACF,CAAC;CACH;CAEA,qBAAqB,WAAW,UAAU;EACxC,oBAAoB,oBAAoB,WAAW,OAAO,EACxD,iBAAiB;;;;;AAKf,KAAK,QACH,cAAc,KAAK,kBAAkB,KACrC,IAAI,MAAM,MAAM,YAAY,IAAI,MAAM,IAAI,GAC9C,EACF,CAAC;CACH;AACF"}

package/dist/features/active-row/active-row-feature.types.d.ts

@@ -0,0 +1,64 @@
+import { OnChangeFn, Row, RowData, TableFeature, TableFeatures, Updater } from "@tanstack/react-table";
+//#region src/features/active-row/active-row-feature.types.d.ts
+/** O estado da feature. */
+export type TableState_ActiveRow = {
+  /**
+   * O id da linha ativa, a do teclado: a que tem o ponto de Tab e recebe as teclas. Separada da
+   * seleção, que é a do checkbox.
+   * @default null
+   */
+  activeRowId: string | null;
+};
+/** As opções da feature. */
+export type TableOptions_ActiveRow = {
+  /**
+   * Chamada a cada troca da linha ativa, com o updater. Sem ela, a tabela guarda a linha ativa
+   * sozinha. Para controlar o estado, passe esta função e `state.activeRowId`.
+   */
+  onActiveRowIdChange?: OnChangeFn<string | null>;
+};
+/** As APIs da feature na tabela. */
+export type Table_ActiveRow<TFeatures extends TableFeatures, TData extends RowData> = {
+  /** Troca a linha ativa, com um id, `null` ou um updater. */
+  setActiveRowId: (updater: Updater<string | null>) => void;
+  /**
+   * Volta a linha ativa à do `initialState`. Com `defaultState`, volta ao padrão da feature,
+   * `null`.
+   */
+  resetActiveRowId: (defaultState?: boolean) => void;
+  /**
+   * A linha ativa, se ela está no row model atual. Fora dele, como numa linha apagada ou de
+   * outra página, `undefined`.
+   */
+  getActiveRow: () => Row<TFeatures, TData> | undefined;
+};
+/** As APIs da feature na linha. */
+export type Row_ActiveRow = {
+  /** Se esta é a linha ativa. */
+  getIsActive: () => boolean;
+};
+declare module '@tanstack/react-table' {
+  interface Plugins {
+    activeRowFeature: TableFeature;
+  }
+  interface TableState_FeatureMap {
+    activeRowFeature: TableState_ActiveRow;
+  }
+  /**
+   * O `TableState_All` não junta os plugins sozinho. Sem a chave aqui, o `setStateSlice` e a
+   * leitura do `initialState` dentro da feature não a conhecem. Opcional, como as chaves do
+   * TanStack.
+   */
+  interface TableState_All extends Partial<TableState_ActiveRow> {}
+  interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    activeRowFeature: TableOptions_ActiveRow;
+  }
+  interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    activeRowFeature: Table_ActiveRow<TFeatures, TData>;
+  }
+  interface Row_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    activeRowFeature: Row_ActiveRow;
+  }
+}
+//#endregion
+//# sourceMappingURL=active-row-feature.types.d.ts.map

package/dist/features/active-row/active-row-feature.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-row-feature.types.d.ts","names":[],"sources":["../../../src/features/active-row/active-row-feature.types.ts"],"mappings":";;;YAWY;;;;;;EAMV;;;YAIU;;;;;EAKV,sBAAsB;;;YAIZ,gBACV,kBAAkB,eAClB,cAAc;;EAGd,iBAAiB,SAAS;;;;;EAK1B,mBAAmB;;;;;EAKnB,oBAAoB,IAAI,WAAW;;;YAIzB;;EAEV;;;YASU;IACR,kBAAkB;;YAGV;IACR,kBAAkB;;;;;;;YAQV,uBAAuB,QAAQ;YAE/B,wBACR,kBAAkB,eAClB,cAAc;IAEd,kBAAkB;;YAGV,iBACR,kBAAkB,eAClB,cAAc;IAEd,kBAAkB,gBAAgB,WAAW;;YAGrC,eACR,kBAAkB,eAClB,cAAc;IAEd,kBAAkB"}

package/dist/features/column-alignment/column-alignment-feature.d.ts

@@ -0,0 +1,23 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/column-alignment/column-alignment-feature.d.ts
+/**
+ * Feature do TanStack Table para o alinhamento por coluna. Registre com essa chave:
+ * `tableFeatures({ columnAlignmentFeature })`.
+ *
+ * Não tem estado: o alinhamento vem do `align` da definição da coluna, e não muda em runtime. A
+ * `DataTable.Cell` e a `DataTable.HeaderCell` o leem por `column.getAlign()` e o marcam em
+ * `data-align`.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, columnAlignmentFeature });
+ *
+ * const columns = columnHelper.columns([
+ *   columnHelper.accessor('name', { header: 'Nome' }),
+ *   columnHelper.accessor('total', { header: 'Total', align: 'end' }),
+ * ]);
+ * ```
+ */
+export declare const columnAlignmentFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=column-alignment-feature.d.ts.map

package/dist/features/column-alignment/column-alignment-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-alignment-feature.d.ts","names":[],"sources":["../../../src/features/column-alignment/column-alignment-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA8Ba,wBAAwB"}

package/dist/features/column-alignment/column-alignment-feature.js

@@ -0,0 +1,34 @@
+import { assignPrototypeAPIs } from "@tanstack/react-table";
+//#region src/features/column-alignment/column-alignment-feature.ts
+/** O alinhamento de uma coluna sem `align` na definição. */
+const DEFAULT_COLUMN_ALIGN = "start";
+/**
+* Feature do TanStack Table para o alinhamento por coluna. Registre com essa chave:
+* `tableFeatures({ columnAlignmentFeature })`.
+*
+* Não tem estado: o alinhamento vem do `align` da definição da coluna, e não muda em runtime. A
+* `DataTable.Cell` e a `DataTable.HeaderCell` o leem por `column.getAlign()` e o marcam em
+* `data-align`.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, columnAlignmentFeature });
+*
+* const columns = columnHelper.columns([
+*   columnHelper.accessor('name', { header: 'Nome' }),
+*   columnHelper.accessor('total', { header: 'Total', align: 'end' }),
+* ]);
+* ```
+*/
+const columnAlignmentFeature = { assignColumnPrototype: (prototype, table) => {
+	assignPrototypeAPIs("columnAlignmentFeature", prototype, table, { column_getAlign: { 
+	/**
+	* O TanStack chama com a coluna de uma tabela qualquer: o tipo com todas as features é o
+	* que conhece o `align`.
+	*/
+fn: (column) => column.columnDef.align ?? DEFAULT_COLUMN_ALIGN } });
+} };
+//#endregion
+export { columnAlignmentFeature };
+
+//# sourceMappingURL=column-alignment-feature.js.map

package/dist/features/column-alignment/column-alignment-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-alignment-feature.js","names":[],"sources":["../../../src/features/column-alignment/column-alignment-feature.ts"],"sourcesContent":["import {\n  assignPrototypeAPIs,\n  type Column,\n  type RowData,\n  type TableFeature,\n  type TableFeatures,\n} from '@tanstack/react-table';\nimport type { ColumnAlign } from './column-alignment-feature.types';\n\n/** O alinhamento de uma coluna sem `align` na definição. */\nconst DEFAULT_COLUMN_ALIGN: ColumnAlign = 'start';\n\n/**\n * Feature do TanStack Table para o alinhamento por coluna. Registre com essa chave:\n * `tableFeatures({ columnAlignmentFeature })`.\n *\n * Não tem estado: o alinhamento vem do `align` da definição da coluna, e não muda em runtime. A\n * `DataTable.Cell` e a `DataTable.HeaderCell` o leem por `column.getAlign()` e o marcam em\n * `data-align`.\n *\n * @example\n * ```ts\n * const features = tableFeatures({ columnSizingFeature, columnAlignmentFeature });\n *\n * const columns = columnHelper.columns([\n *   columnHelper.accessor('name', { header: 'Nome' }),\n *   columnHelper.accessor('total', { header: 'Total', align: 'end' }),\n * ]);\n * ```\n */\nexport const columnAlignmentFeature: TableFeature = {\n  assignColumnPrototype: (prototype, table) => {\n    assignPrototypeAPIs('columnAlignmentFeature', prototype, table, {\n      column_getAlign: {\n        /**\n         * O TanStack chama com a coluna de uma tabela qualquer: o tipo com todas as features é o\n         * que conhece o `align`.\n         */\n        fn: (column: Column<TableFeatures, RowData>) =>\n          column.columnDef.align ?? DEFAULT_COLUMN_ALIGN,\n      },\n    });\n  },\n};\n"],"mappings":";;;AAUA,MAAM,uBAAoC;;;;;;;;;;;;;;;;;;;AAoB1C,MAAa,yBAAuC,EAClD,wBAAwB,WAAW,UAAU;CAC3C,oBAAoB,0BAA0B,WAAW,OAAO,EAC9D,iBAAiB;;;;;AAKf,KAAK,WACH,OAAO,UAAU,SAAS,qBAC9B,EACF,CAAC;AACH,EACF"}

package/dist/features/column-alignment/column-alignment-feature.types.d.ts

@@ -0,0 +1,34 @@
+import { CellData, RowData, TableFeature, TableFeatures } from "@tanstack/react-table";
+//#region src/features/column-alignment/column-alignment-feature.types.d.ts
+/**
+ * O alinhamento do conteúdo de uma coluna. Em direção lógica: `start` e `end` seguem a direção
+ * do texto, à esquerda e à direita num idioma LTR.
+ */
+export type ColumnAlign = 'start' | 'center' | 'end';
+/** As opções da feature na definição da coluna. */
+export type ColumnDef_ColumnAlignment = {
+  /**
+   * O alinhamento do conteúdo das células e do header da coluna. Para mudar o padrão da tabela
+   * inteira, passe no `defaultColumn`.
+   * @default 'start'
+   */
+  align?: ColumnAlign;
+};
+/** As APIs da feature na coluna. */
+export type Column_ColumnAlignment = {
+  /** O alinhamento da coluna: o `align` da definição, ou `'start'`. */
+  getAlign: () => ColumnAlign;
+};
+declare module '@tanstack/react-table' {
+  interface Plugins {
+    columnAlignmentFeature: TableFeature;
+  }
+  interface ColumnDef_FeatureMap<TFeatures extends TableFeatures, TData extends RowData, TValue extends CellData> {
+    columnAlignmentFeature: ColumnDef_ColumnAlignment;
+  }
+  interface Column_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    columnAlignmentFeature: Column_ColumnAlignment;
+  }
+}
+//#endregion
+//# sourceMappingURL=column-alignment-feature.types.d.ts.map

package/dist/features/column-alignment/column-alignment-feature.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column-alignment-feature.types.d.ts","names":[],"sources":["../../../src/features/column-alignment/column-alignment-feature.types.ts"],"mappings":";;;;;;YAYY;;YAGA;;;;;;EAMV,QAAQ;;;YAIE;;EAEV,gBAAgB;;;YASN;IACR,wBAAwB;;YAGhB,qBACR,kBAAkB,eAClB,cAAc,SACd,eAAe;IAEf,wBAAwB;;YAGhB,kBACR,kBAAkB,eAClB,cAAc;IAEd,wBAAwB"}

package/dist/features/index.d.ts

@@ -0,0 +1,9 @@
+import { activeRowFeature } from "./active-row/active-row-feature.js";
+import { Row_ActiveRow, TableOptions_ActiveRow, TableState_ActiveRow, Table_ActiveRow } from "./active-row/active-row-feature.types.js";
+import { columnAlignmentFeature } from "./column-alignment/column-alignment-feature.js";
+import { ColumnAlign, ColumnDef_ColumnAlignment, Column_ColumnAlignment } from "./column-alignment/column-alignment-feature.types.js";
+import { loadingFeature } from "./loading/loading-feature.js";
+import { TableOptions_Loading, TableState_Loading, Table_Loading } from "./loading/loading-feature.types.js";
+import { rowDensityFeature } from "./row-density/row-density-feature.js";
+import { RowDensity, TableOptions_RowDensity, TableState_RowDensity, Table_RowDensity } from "./row-density/row-density-feature.types.js";
+export { type ColumnAlign, type ColumnDef_ColumnAlignment, type Column_ColumnAlignment, type RowDensity, type Row_ActiveRow, type TableOptions_ActiveRow, type TableOptions_Loading, type TableOptions_RowDensity, type TableState_ActiveRow, type TableState_Loading, type TableState_RowDensity, type Table_ActiveRow, type Table_Loading, type Table_RowDensity, activeRowFeature, columnAlignmentFeature, loadingFeature, rowDensityFeature };

package/dist/features/index.js

@@ -0,0 +1,5 @@
+import { activeRowFeature } from "./active-row/active-row-feature.js";
+import { columnAlignmentFeature } from "./column-alignment/column-alignment-feature.js";
+import { loadingFeature } from "./loading/loading-feature.js";
+import { rowDensityFeature } from "./row-density/row-density-feature.js";
+export { activeRowFeature, columnAlignmentFeature, loadingFeature, rowDensityFeature };

package/dist/features/loading/loading-feature.d.ts

@@ -0,0 +1,30 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.d.ts
+/**
+ * Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:
+ * `tableFeatures({ loadingFeature })`.
+ *
+ * Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`
+ * bloqueia as linhas e, sem linhas, desenha linhas-fantasma.
+ *
+ * Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,
+ * à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma
+ * o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No
+ * TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,
+ * e não `isFetching`.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, loadingFeature });
+ *
+ * const table = useTable({
+ *   features,
+ *   columns,
+ *   data: query.data ?? [],
+ *   state: { isLoading: query.isPending || query.isPlaceholderData },
+ * });
+ * ```
+ */
+export declare const loadingFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=loading-feature.d.ts.map

package/dist/features/loading/loading-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.d.ts","names":[],"sources":["../../../src/features/loading/loading-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBAyCa,gBAAgB"}

package/dist/features/loading/loading-feature.js

@@ -0,0 +1,48 @@
+import { assignTableAPIs, makeStateUpdater, setStateSlice } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.ts
+/** O carregamento sem `initialState`. */
+const DEFAULT_IS_LOADING = false;
+/** O carregamento de um estado inicial, ou o padrão quando ele não traz. */
+const getInitialIsLoading = (initialState) => initialState.isLoading ?? DEFAULT_IS_LOADING;
+/**
+* Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:
+* `tableFeatures({ loadingFeature })`.
+*
+* Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`
+* bloqueia as linhas e, sem linhas, desenha linhas-fantasma.
+*
+* Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,
+* à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma
+* o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No
+* TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,
+* e não `isFetching`.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, loadingFeature });
+*
+* const table = useTable({
+*   features,
+*   columns,
+*   data: query.data ?? [],
+*   state: { isLoading: query.isPending || query.isPlaceholderData },
+* });
+* ```
+*/
+const loadingFeature = {
+	getInitialState: (initialState) => ({
+		isLoading: DEFAULT_IS_LOADING,
+		...initialState
+	}),
+	getDefaultTableOptions: (table) => ({ onIsLoadingChange: makeStateUpdater("isLoading", table) }),
+	constructTableAPIs: (table) => {
+		assignTableAPIs("loadingFeature", table, {
+			table_setIsLoading: { fn: (updater) => setStateSlice(table, "isLoading", updater) },
+			table_resetIsLoading: { fn: (defaultState) => setStateSlice(table, "isLoading", defaultState ? DEFAULT_IS_LOADING : getInitialIsLoading(table.initialState)) }
+		});
+	}
+};
+//#endregion
+export { loadingFeature };
+
+//# sourceMappingURL=loading-feature.js.map

package/dist/features/loading/loading-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.js","names":[],"sources":["../../../src/features/loading/loading-feature.ts"],"sourcesContent":["import {\n  assignTableAPIs,\n  makeStateUpdater,\n  setStateSlice,\n  type TableFeature,\n  type TableState_All,\n  type Updater,\n} from '@tanstack/react-table';\n\n/** O carregamento sem `initialState`. */\nconst DEFAULT_IS_LOADING = false;\n\n/** O carregamento de um estado inicial, ou o padrão quando ele não traz. */\nconst getInitialIsLoading = (initialState: Partial<TableState_All>) =>\n  initialState.isLoading ?? DEFAULT_IS_LOADING;\n\n/**\n * Feature do TanStack Table para o carregamento dos dados. Registre com essa chave:\n * `tableFeatures({ loadingFeature })`.\n *\n * Só guarda o estado: o `DataTable.Root` marca o grid enquanto carrega, o `DataTable.Body`\n * bloqueia as linhas e, sem linhas, desenha linhas-fantasma.\n *\n * Carregar é ter na tela linhas que não são as da consulta atual: as de outra página ou ordem,\n * à espera das novas, ou nenhuma na primeira carga. Uma busca em segundo plano que só confirma\n * o que já está na tela não conta: marcá-la cobriria com o skeleton as linhas certas. No\n * TanStack Query, com `placeholderData: keepPreviousData`, isso é `isPending || isPlaceholderData`,\n * e não `isFetching`.\n *\n * @example\n * ```ts\n * const features = tableFeatures({ columnSizingFeature, loadingFeature });\n *\n * const table = useTable({\n *   features,\n *   columns,\n *   data: query.data ?? [],\n *   state: { isLoading: query.isPending || query.isPlaceholderData },\n * });\n * ```\n */\nexport const loadingFeature: TableFeature = {\n  getInitialState: (initialState) => ({\n    isLoading: DEFAULT_IS_LOADING,\n    ...initialState,\n  }),\n\n  getDefaultTableOptions: (table) => ({\n    onIsLoadingChange: makeStateUpdater('isLoading', table),\n  }),\n\n  constructTableAPIs: (table) => {\n    assignTableAPIs('loadingFeature', table, {\n      table_setIsLoading: {\n        fn: (updater: Updater<boolean>) =>\n          setStateSlice(table, 'isLoading', updater),\n      },\n      table_resetIsLoading: {\n        fn: (defaultState?: boolean) =>\n          setStateSlice(\n            table,\n            'isLoading',\n            defaultState\n              ? DEFAULT_IS_LOADING\n              : getInitialIsLoading(table.initialState),\n          ),\n      },\n    });\n  },\n};\n"],"mappings":";;;AAUA,MAAM,qBAAqB;;AAG3B,MAAM,uBAAuB,iBAC3B,aAAa,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;AA2B5B,MAAa,iBAA+B;CAC1C,kBAAkB,kBAAkB;EAClC,WAAW;EACX,GAAG;CACL;CAEA,yBAAyB,WAAW,EAClC,mBAAmB,iBAAiB,aAAa,KAAK,EACxD;CAEA,qBAAqB,UAAU;EAC7B,gBAAgB,kBAAkB,OAAO;GACvC,oBAAoB,EAClB,KAAK,YACH,cAAc,OAAO,aAAa,OAAO,EAC7C;GACA,sBAAsB,EACpB,KAAK,iBACH,cACE,OACA,aACA,eACI,qBACA,oBAAoB,MAAM,YAAY,CAC5C,EACJ;EACF,CAAC;CACH;AACF"}

package/dist/features/loading/loading-feature.types.d.ts

@@ -0,0 +1,50 @@
+import { OnChangeFn, RowData, TableFeature, TableFeatures, Updater } from "@tanstack/react-table";
+//#region src/features/loading/loading-feature.types.d.ts
+/** O estado da feature. */
+export type TableState_Loading = {
+  /**
+   * Se os dados da tabela estão carregando.
+   * @default false
+   */
+  isLoading: boolean;
+};
+/** As opções da feature. */
+export type TableOptions_Loading = {
+  /**
+   * Chamada a cada troca do carregamento, com o updater. Para ligar o carregamento ao da consulta
+   * do app, passe `state.isLoading` (ver a `loadingFeature`).
+   */
+  onIsLoadingChange?: OnChangeFn<boolean>;
+};
+/** As APIs da feature na tabela. */
+export type Table_Loading = {
+  /** Liga ou desliga o carregamento, com um valor ou um updater. */
+  setIsLoading: (updater: Updater<boolean>) => void;
+  /**
+   * Volta o carregamento ao do `initialState`. Com `defaultState`, volta ao padrão da feature,
+   * `false`.
+   */
+  resetIsLoading: (defaultState?: boolean) => void;
+};
+declare module '@tanstack/react-table' {
+  interface Plugins {
+    loadingFeature: TableFeature;
+  }
+  interface TableState_FeatureMap {
+    loadingFeature: TableState_Loading;
+  }
+  /**
+   * O `TableState_All` não junta os plugins sozinho. Sem a chave aqui, o `setStateSlice` e a
+   * leitura do `initialState` dentro da feature não a conhecem. Opcional, como as chaves do
+   * TanStack.
+   */
+  interface TableState_All extends Partial<TableState_Loading> {}
+  interface TableOptions_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    loadingFeature: TableOptions_Loading;
+  }
+  interface Table_FeatureMap<TFeatures extends TableFeatures, TData extends RowData> {
+    loadingFeature: Table_Loading;
+  }
+}
+//#endregion
+//# sourceMappingURL=loading-feature.types.d.ts.map

package/dist/features/loading/loading-feature.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loading-feature.types.d.ts","names":[],"sources":["../../../src/features/loading/loading-feature.types.ts"],"mappings":";;;YAUY;;;;;EAKV;;;YAIU;;;;;EAKV,oBAAoB;;;YAIV;;EAEV,eAAe,SAAS;;;;;EAKxB,iBAAiB;;;YASP;IACR,gBAAgB;;YAGR;IACR,gBAAgB;;;;;;;YAQR,uBAAuB,QAAQ;YAE/B,wBACR,kBAAkB,eAClB,cAAc;IAEd,gBAAgB;;YAGR,iBACR,kBAAkB,eAClB,cAAc;IAEd,gBAAgB"}

package/dist/features/row-density/row-density-feature.d.ts

@@ -0,0 +1,26 @@
+import { TableFeature } from "@tanstack/react-table";
+//#region src/features/row-density/row-density-feature.d.ts
+/**
+ * Feature do TanStack Table para a densidade das linhas. Registre com essa chave:
+ * `tableFeatures({ rowDensityFeature })`.
+ *
+ * Só guarda o estado: o `DataTable.Root` o lê e marca o grid com `data-density`, de onde as
+ * células tiram altura e espaçamento.
+ *
+ * @example
+ * ```ts
+ * const features = tableFeatures({ columnSizingFeature, rowDensityFeature });
+ *
+ * const table = useTable({
+ *   features,
+ *   columns,
+ *   data,
+ *   initialState: { rowDensity: 'compact' },
+ * });
+ *
+ * table.setRowDensity('airy');
+ * ```
+ */
+export declare const rowDensityFeature: TableFeature;
+//#endregion
+//# sourceMappingURL=row-density-feature.d.ts.map

package/dist/features/row-density/row-density-feature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-density-feature.d.ts","names":[],"sources":["../../../src/features/row-density/row-density-feature.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBAsCa,mBAAmB"}

package/dist/features/row-density/row-density-feature.js

@@ -0,0 +1,44 @@
+import { assignTableAPIs, makeStateUpdater, setStateSlice } from "@tanstack/react-table";
+//#region src/features/row-density/row-density-feature.ts
+/** A densidade sem `initialState`. */
+const DEFAULT_ROW_DENSITY = "standard";
+/** A densidade de um estado inicial, ou a padrão quando ele não traz. */
+const getInitialRowDensity = (initialState) => initialState.rowDensity ?? DEFAULT_ROW_DENSITY;
+/**
+* Feature do TanStack Table para a densidade das linhas. Registre com essa chave:
+* `tableFeatures({ rowDensityFeature })`.
+*
+* Só guarda o estado: o `DataTable.Root` o lê e marca o grid com `data-density`, de onde as
+* células tiram altura e espaçamento.
+*
+* @example
+* ```ts
+* const features = tableFeatures({ columnSizingFeature, rowDensityFeature });
+*
+* const table = useTable({
+*   features,
+*   columns,
+*   data,
+*   initialState: { rowDensity: 'compact' },
+* });
+*
+* table.setRowDensity('airy');
+* ```
+*/
+const rowDensityFeature = {
+	getInitialState: (initialState) => ({
+		rowDensity: DEFAULT_ROW_DENSITY,
+		...initialState
+	}),
+	getDefaultTableOptions: (table) => ({ onRowDensityChange: makeStateUpdater("rowDensity", table) }),
+	constructTableAPIs: (table) => {
+		assignTableAPIs("rowDensityFeature", table, {
+			table_setRowDensity: { fn: (updater) => setStateSlice(table, "rowDensity", updater) },
+			table_resetRowDensity: { fn: (defaultState) => setStateSlice(table, "rowDensity", defaultState ? DEFAULT_ROW_DENSITY : getInitialRowDensity(table.initialState)) }
+		});
+	}
+};
+//#endregion
+export { rowDensityFeature };
+
+//# sourceMappingURL=row-density-feature.js.map