sit-onyx 1.0.0-beta.99 → 1.0.0

package/dist/components/OnyxDataGrid/features/filtering/types.d.ts

@@ -0,0 +1,66 @@
+import { Ref } from 'vue';
+import { DataGridEntry } from '../../types.js';
+import { DataGridFeatureOptions } from '../index.js';
+/**
+ * Configuration for how filtering should behave.
+ */
+export type FilterConfig<TEntry extends DataGridEntry> = {
+    /**
+     * A custom filtering function for this column.
+     * This function is used to filter the column data, instead of using the default filtering behavior.
+     */
+    filterFunc?: (
+    /**
+     * The searchTerm as entered by the user.
+     */
+    searchTerm: string, 
+    /**
+     * The current row value to be checked.
+     */
+    value: TEntry[keyof TEntry], 
+    /**
+     * The column that is filtered by.
+     */
+    column: keyof TEntry, 
+    /**
+     * The complete row data.
+     */
+    entry: TEntry) => boolean;
+    /**
+     * If true, filtering will be case-sensitive.
+     * If false, filtering will be case-insensitive.
+     */
+    caseSensitive?: boolean;
+    /**
+     * If true, the filter will start searching from the beginning of the value.
+     * If false, it will search anywhere in the value.
+     */
+    searchFromStart?: boolean;
+    /**
+     * If true, the filter will match the value exactly, without partial matches.
+     * If false, partial matches will be allowed.
+     */
+    exactMatch?: boolean;
+};
+/**
+ * Defines the current filter/search term per column
+ */
+export type FilterState<TEntry> = Partial<Record<keyof TEntry, string | undefined>>;
+/**
+ * The configuration options for the filtering feature in the OnyxDataGrid component.
+ * Includes settings for the individual columns and general filter behavior.
+ */
+export type FilterOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, {
+    [TKey in keyof TEntry]?: {
+        /**
+         * Configuration for how filtering should behave for this column.
+         */
+        config?: FilterConfig<TEntry>;
+    };
+}, true> & {
+    filterState?: Ref<FilterState<TEntry>>;
+    /**
+     * Configuration for how the filtering should behave across all columns.
+     */
+    filterConfig?: FilterConfig<TEntry>;
+};

package/dist/components/OnyxDataGrid/features/hideColumns/hideColumns.d.ts

@@ -0,0 +1,43 @@
+import { Ref } from 'vue';
+import { DataGridEntry } from '../../types.js';
+import { InternalColumnConfig } from '../index.js';
+import { HideColumnsOptions, HideColumnsState } from './types.js';
+export declare const HIDE_COLUMNS_FEATURE: unique symbol;
+export declare const HIDDEN_COLUMN: unique symbol;
+export declare const useHideColumns: <TEntry extends DataGridEntry>(options?: HideColumnsOptions<TEntry>) => (ctx: import('../index.js').DataGridFeatureContext) => {
+    name: symbol;
+    watch: Ref<HideColumnsState<TEntry>, HideColumnsState<TEntry>>[];
+    modifyColumns: {
+        order: number;
+        /**
+         * Store the current column configuration for later reference
+         */
+        func: (newConfig: readonly InternalColumnConfig<TEntry, any>[]) => readonly InternalColumnConfig<TEntry, any>[];
+    }[];
+    typeRenderer: {
+        [HIDDEN_COLUMN]: {
+            header: {
+                thAttributes: {
+                    class: string;
+                };
+                component: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                    [key: string]: any;
+                }>;
+            };
+            cell: {
+                tdAttributes: {
+                    class: string;
+                };
+                component: () => null;
+            };
+        };
+    };
+    header: {
+        actions: ({ key: column }: InternalColumnConfig<any, any>) => {
+            menuItems: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>[];
+            showFlyoutMenu: true;
+        }[];
+    };
+};

package/dist/components/OnyxDataGrid/features/hideColumns/types.d.ts

@@ -0,0 +1,13 @@
+import { MaybeRef } from 'vue';
+import { DataGridEntry } from '../../types.js';
+import { DataGridFeatureOptions } from '../index.js';
+export type HideColumnsState<TEntry extends DataGridEntry> = Set<keyof TEntry>;
+/**
+ * The options of the sorting feature for the OnyxDataGrid component.
+ */
+export type HideColumnsOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, object> & {
+    /**
+     * List of column keys that are hidden.
+     */
+    state?: MaybeRef<HideColumnsState<TEntry>>;
+};

package/dist/components/OnyxDataGrid/features/index.d.ts

@@ -1,8 +1,119 @@
-import { type Component, type WatchSource } from "vue";
-import OnyxListItem from "../../OnyxListItem/OnyxListItem.vue";
-import type { DataGridRendererColumn, DataGridRendererRow } from "../OnyxDataGridRenderer/types";
-import type { DataGridEntry, DataGridMetadata } from "../types";
-export type DataGridFeature<TEntry extends DataGridEntry, TFeatureName extends symbol> = {
+import { Component, HTMLAttributes, MaybeRef, MaybeRefOrGetter, Ref, TdHTMLAttributes, ThHTMLAttributes, VNode, VNodeProps, WatchSource } from 'vue';
+import { OnyxI18n } from '../../../i18n/index.js';
+import { Nullable } from '../../../types/index.js';
+import { OrderableMapping } from '../../../utils/feature.js';
+import { OnyxMenuItem } from '../../OnyxNavBar/modules/index.js';
+import { OnyxTableSlots, TableColumnGroup } from '../../OnyxTable/types.js';
+import { DataGridRendererCell, DataGridRendererColumn, DataGridRendererRow } from '../OnyxDataGridRenderer/types.js';
+import { ColumnTypesFromFeatures, DataGridEntry, DataGridMetadata } from '../types.js';
+import { BASE_FEATURE } from './base/base.js';
+/**
+ * Function type for modifying the normalized column configuration.
+ */
+export type ModifyColumns<TEntry extends DataGridEntry> = OrderableMapping<InternalColumnConfig<TEntry>[]>;
+export type HeaderCellProps<TOptions = unknown> = {
+    label: string;
+    typeOptions?: TOptions;
+};
+export type TypeRendererHeaderDef<TEntry extends DataGridEntry, TOptions = undefined> = Omit<DataGridRendererColumn<TEntry, HeaderCellProps<TOptions>>, "key" | "props">;
+export type CellMetadata<TOptions = unknown> = {
+    typeOptions?: TOptions;
+};
+export type TypeRendererCell<TEntry extends DataGridEntry, TOptions = undefined> = Omit<DataGridRendererCell<TEntry, CellMetadata<TOptions>>, "props">;
+/**
+ * Defines how a specific column type should be rendered.
+ */
+export type TypeRenderer<TEntry extends DataGridEntry, TOptions = undefined> = {
+    header?: TypeRendererHeaderDef<TEntry, TOptions>;
+    cell: TypeRendererCell<TEntry, TOptions>;
+};
+/**
+ * Maps a "type" key to a column renderer.
+ * `symbol` keys are intended for internal/helper columns.
+ */
+export type TypeRenderMap<TEntry extends DataGridEntry, TKey extends PropertyKey = PropertyKey> = Partial<Record<TKey, Readonly<TypeRenderer<TEntry, object>>>>;
+/**
+ * ColumnConfig as it can be defined by the user.
+ */
+export type ColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig = Record<string, never>, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown> = never> = keyof TEntry | PublicNormalizedColumnConfig<TEntry, TColumnGroup, TTypes | ColumnTypesFromFeatures<ReturnType<typeof BASE_FEATURE>>>;
+export type DefaultSupportedTypes = keyof ReturnType<ReturnType<typeof BASE_FEATURE>>["typeRenderer"];
+/**
+ * Configuration for the column groupings.
+ */
+export type ColumnGroupConfig = Record<string, {
+    label: string;
+}>;
+/**
+ * Column config used internally and by the `modifyColumns` functions.
+ */
+export type InternalColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig = any> = Omit<PublicNormalizedColumnConfig<TEntry, TColumnGroup, never>, "label" | "type"> & {
+    type: ColumnTypeNormalized<PropertyKey, unknown>;
+    /**
+     * Attributes that should be set on all `td` elements
+     */
+    tdAttributes?: TdHTMLAttributes;
+    /**
+     * Attributes that should be set on all `th` elements
+     */
+    thAttributes?: ThHTMLAttributes;
+    /**
+     * After normalization the label is always defined.
+     */
+    label: string;
+};
+export type ColumnTypeNormalized<TKey, TOptions> = {
+    name: TKey;
+    options?: TOptions;
+};
+export type ColumnConfigTypeOption<TKey, TOptions> = TKey | ColumnTypeNormalized<TKey, TOptions>;
+/**
+ * Normalized column config for public/external usage.
+ */
+export type PublicNormalizedColumnConfig<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>> = Pick<DataGridRendererColumn<TEntry>, "width" | "key"> & {
+    /**
+     * The `label` is displayed in the data grid as column header.
+     * If not defined, the key is used instead.
+     */
+    label?: string;
+    /**
+     * The `type` of the column. It defines how the header and cells of a column is rendered.
+     * If not defined the values are displayed as plain strings.
+     */
+    type?: TTypes;
+    /**
+     * Key of the ColumnGroup that this column should be visually grouped in.
+     * The columns have to be defined in the correct order.
+     * So columns that should be grouped together have to actually be defined after each other.
+     *
+     * The label for the column group can be configured via the `columnGroups` prop.
+     */
+    columnGroupKey?: keyof TColumnGroup;
+};
+/**
+ * Context that is passed to a feature when it is set up by the `useDataGridFeatures` composable.
+ */
+export type DataGridFeatureContext = {
+    /**
+     * Ref for the `async` state of the `OnyxDataGrid`. If `true` data mutations should be skipped, if they are expected to be handled by a backend.
+     */
+    async: Readonly<Ref<boolean>>;
+    /**
+     * The `i18n` object, which can be used to access messages, formatters and the current locale.
+     */
+    i18n: OnyxI18n;
+    /**
+     * Whether the data grid should be shows as skeleton.
+     */
+    skeleton: Readonly<Ref<number | boolean>>;
+};
+/**
+ * Complete Type for a single data grid feature.
+ */
+export type DataGridFeature<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = (ctx: DataGridFeatureContext) => DataGridFeatureDescription<TEntry, TTypeRenderer, TFeatureName>;
+/**
+ * Object that describes the hooks and properties of a datagrid feature.
+ */
+export type DataGridFeatureDescription<TEntry extends DataGridEntry, TTypeRenderer extends TypeRenderMap<TEntry> = TypeRenderMap<TEntry>, TFeatureName extends symbol = symbol> = {
     /**
      * Unique name and identifier of the datagrid feature
      */
@@ -10,13 +121,39 @@ export type DataGridFeature<TEntry extends DataGridEntry, TFeatureName extends s
     /**
      * An array of reactive states that should trigger a datagrid re-generation
      */
-    watch: WatchSource[];
+    watch?: WatchSource[];
     /**
      * Allows modifying the datagrid state as a whole.
      */
     mutation?: {
-        func: (state: Readonly<TEntry>[]) => void;
+        func: (state: Readonly<TEntry>[]) => Readonly<TEntry>[] | void;
+        /**
+         * Defines the order in which the mutation is handled.
+         * This can be used to control the sequence of operations when multiple mutations are applied.
+         *
+         * The higher the order, the earlier the mutation is applied.
+         *
+         * @default 0
+         */
+        order?: number;
     };
+    /**
+     * Defines a renderer for a column type.
+     */
+    typeRenderer?: TTypeRenderer;
+    /**
+     * Allows modification of the normalized column configuration.
+     * While the entries are passed as readonly, but the array itself can be modified.
+     * To change entries, you need to clone them first:
+     *
+     * @example
+     * ```ts
+     * {
+     *   modifyColumns: [ { func: (config) => configs.map(column => ({ ...column, type: "newType" })) } ];
+     * }
+     * ```
+     */
+    modifyColumns?: ModifyColumns<TEntry>;
     /**
      * Allows the modification of the headers.
      */
@@ -26,14 +163,56 @@ export type DataGridFeature<TEntry extends DataGridEntry, TFeatureName extends s
          * `iconComponent` of an action is shown after the header label.
          * The components must be ARIA-conform buttons.
          */
-        actions?: (column: keyof TEntry) => {
-            iconComponent: Component;
-            listItems: Component<typeof OnyxListItem>[];
+        actions?: (column: InternalColumnConfig<TEntry>, index: number, all: InternalColumnConfig<TEntry>[]) => {
+            iconComponent?: Component | {
+                iconComponent: Component;
+                /**
+                 * Will force the icon component to be always shown in the header and not be put into the menu
+                 */
+                alwaysShowInHeader?: boolean;
+            };
+            menuItems?: Component<typeof OnyxMenuItem>[];
+            showFlyoutMenu?: boolean;
         }[];
+        wrapper?: (column: InternalColumnConfig<TEntry>, index: number, all: InternalColumnConfig<TEntry>[]) => Component;
     };
+    scrollContainerAttributes?: () => DataGridScrollContainerAttributes;
+    /**
+     * Optional table slots.
+     */
+    slots?: DataGridFeatureSlots;
 };
+export type DataGridScrollContainerAttributes = HTMLAttributes & Pick<VNodeProps, "ref">;
+export type DataGridFeatureSlots = Partial<{
+    [TSlotName in keyof Pick<OnyxTableSlots, "headline" | "bottomLeft" | "pagination">]: (slotContent: () => VNode[]) => Nullable<VNode>[];
+}>;
+export type InternalDataGridSlots = Partial<Record<keyof DataGridFeatureSlots, () => VNode[]>>;
+export type DataGridFeatureOptions<TEntry extends DataGridEntry, TColumnOptions extends Partial<Record<keyof TEntry, object>>, TWithAsync extends boolean = false> = {
+    /**
+     * Whether the feature is enabled by default. Can be overridden per column.
+     *
+     * @default true
+     */
+    enabled?: MaybeRef<boolean | undefined>;
+    /**
+     * Options for each column. Will override default/global options of the feature.
+     */
+    columns?: MaybeRef<{
+        [TKey in keyof TEntry]?: TColumnOptions[TKey] & {
+            /**
+             * Whether the feature is enabled for this column. If unset, the default/global `enabled` option of this feature will be used.
+             */
+            enabled?: boolean;
+        };
+    } | undefined>;
+} & (TWithAsync extends true ? {
+    /**
+     * When async is `true`, then the internal data transformations of this feature  are disabled and have to be performed manually.
+     */
+    async?: boolean;
+} : unknown);
 /**
- * Helper function that infers the generics of the DataGridFeature type.
+ * Helper function that checks the generics of the DataGridFeature type, without breaking type inference.
  * @example
  * ```ts
  *
@@ -52,7 +231,16 @@ export type DataGridFeature<TEntry extends DataGridEntry, TFeatureName extends s
  * });
  * ```
  */
-export declare function createFeature<TEntry extends DataGridEntry, TFeatureName extends symbol, TArgs extends unknown[]>(featureDefinition: (...args: TArgs) => DataGridFeature<TEntry, TFeatureName>): (...args: TArgs) => DataGridFeature<TEntry, TFeatureName>;
+export declare function createFeature<TFeature extends DataGridFeature<any, any, any>, T extends CheckDataGridFeature<TFeature>>(featureDefinition: T): T;
+type CheckDataGridFeature<T> = T extends DataGridFeature<infer A, TypeRenderMap<infer A>, infer C> ? DataGridFeature<A, TypeRenderMap<A>, C> : never;
+export type UseDataGridFeaturesOptions<TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>> = {
+    columnConfig: MaybeRefOrGetter<ColumnConfig<TEntry, TColumnGroup, TTypes>[]>;
+    i18n: OnyxI18n;
+    columnGroups: MaybeRefOrGetter<TColumnGroup>;
+    async: Readonly<Ref<boolean>>;
+    skeleton: DataGridFeatureContext["skeleton"];
+};
+export declare const createTableColumnGroups: <TEntry extends DataGridEntry, TColumnGroup extends ColumnGroupConfig>(columns?: InternalColumnConfig<TEntry, TColumnGroup>[], columnGroups?: ColumnGroupConfig) => TableColumnGroup[] | undefined;
 /**
  * Uses the defined datagrid features to provide factory functions.
  * These factories are to be used to map data and configuration to `OnyxDataGridRenderer` properties.
@@ -87,10 +275,32 @@ export declare function createFeature<TEntry extends DataGridEntry, TFeatureName
  * </template>
  * ```
  */
-export declare const useDataGridFeatures: <TEntry extends DataGridEntry, T extends DataGridFeature<TEntry, symbol>[] | []>(features: T) => {
+export declare const useDataGridFeatures: <TEntry extends DataGridEntry, TFeatureName extends symbol, TTypeRenderer extends TypeRenderMap<TEntry>, TColumnGroup extends ColumnGroupConfig, TTypes extends ColumnConfigTypeOption<PropertyKey, unknown>, T extends DataGridFeature<TEntry, TTypeRenderer, TFeatureName>[] | []>(featureDefinitions: T, { i18n, columnConfig, columnGroups, async, skeleton, }: UseDataGridFeaturesOptions<TEntry, TColumnGroup, TTypes>) => {
+    /**
+     * Takes the table attributes and maps all
+     */
+    createScrollContainerAttributes: () => never;
+    /** Uses the column definition and available column group config to generate the column groups for the underlying OnyxTable */
+    createRendererColumnGroups: () => TableColumnGroup[] | undefined;
     /** Takes the column definition and maps all, calls mutation func and maps at the end to RendererCell */
-    createRendererRows: (entries: TEntry[], columns: (keyof TEntry)[]) => DataGridRendererRow<TEntry, DataGridMetadata>[];
+    createRendererRows: (entries: TEntry[]) => DataGridRendererRow<TEntry, DataGridMetadata>[];
     /** Takes the column definition and creates a RenderHeader for each, adds actions from features */
-    createRendererColumns: (columns: (keyof TEntry)[]) => DataGridRendererColumn<TEntry, object>[];
+    createRendererColumns: () => DataGridRendererColumn<TEntry>[];
+    /** Uses all features and generates the content of the additional table slots (headline, pagination etc.) for the underlying OnyxTable */
+    createSlots: () => Partial<Record<"pagination" | "headline" | "bottomLeft", () => VNode[]>>;
     watchSources: WatchSource[];
 };
+export declare const useFeatureContext: (ctx: DataGridFeatureContext, options?: DataGridFeatureOptions<DataGridEntry, object, boolean>) => {
+    /**
+     * Checks whether a data grid feature is enabled for a given column.
+     * Considers the feature defaults as well as column-specific overrides.
+     *
+     * @default true
+     */
+    isEnabled: import('vue').ComputedRef<(column?: PropertyKey) => boolean>;
+    /**
+     * Whether the feature only or all features have data transformations enabled.
+     */
+    isAsync: import('vue').ComputedRef<boolean>;
+};
+export {};

package/dist/components/OnyxDataGrid/features/pagination/pagination.d.ts

@@ -0,0 +1,28 @@
+import { Ref } from 'vue';
+import { PaginationOptions, PaginationState } from './types.js';
+export declare const PAGINATION_FEATURE: unique symbol;
+export declare const LAZY_LOADING_ROW_ID: unique symbol;
+export declare const LAZY_LOADING_TYPE_RENDERER: unique symbol;
+export declare const BUTTON_LOADING_ROW_ID: unique symbol;
+export declare const BUTTON_LOADING_TYPE_RENDERER: unique symbol;
+export declare const PAGINATION_MUTATION_ORDER: number;
+export declare const usePagination: (options?: PaginationOptions) => (ctx: import('../index.js').DataGridFeatureContext) => {
+    name: symbol;
+    watch: (Readonly<Ref<number | boolean, number | boolean>> | import('vue').ComputedRef<(column?: PropertyKey) => boolean> | Ref<PaginationState, PaginationState>)[];
+    mutation: {
+        order: number;
+        func: (entries: Readonly<any>[]) => Readonly<any>[];
+    };
+    typeRenderer: {
+        [LAZY_LOADING_TYPE_RENDERER]: Readonly<import('../index.js').TypeRenderer<any, object>>;
+        [BUTTON_LOADING_TYPE_RENDERER]: Readonly<import('../index.js').TypeRenderer<any, object>>;
+    };
+    slots: {
+        pagination: () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>[];
+    };
+    scrollContainerAttributes: () => {
+        ref: (el: Element | import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null) => void;
+    };
+};

package/dist/components/OnyxDataGrid/features/pagination/types.d.ts

@@ -0,0 +1,51 @@
+import { Ref } from 'vue';
+import { DataGridEntry } from '../../types.js';
+import { DataGridFeatureOptions } from '../index.js';
+/**
+ * The configuration options for the pagination feature in the OnyxDataGrid component.
+ */
+export type PaginationOptions = Pick<DataGridFeatureOptions<DataGridEntry, object, true>, "enabled" | "async"> & {
+    /**
+     * How many entries should be displayed per page.
+     *
+     * @default 25
+     */
+    pageSize?: number;
+    /**
+     * The current pagination state. Can be used to e.g. set initial pagination state or pass a custom state (useful when async pagination is used).
+     */
+    paginationState?: Ref<PaginationState>;
+    /**
+     * Whether to disable the pagination.
+     */
+    disabled?: Ref<boolean | undefined>;
+    /**
+     * Defines how the pagination is applied by the user.
+     * - select: user can select a page using the [OnyxPagination](https://storybook.onyx.schwarz/?path=/docs/data-pagination--docs) component
+     * - lazy: current page is increased automatically when the users scrolls to the end of the table. Requires a fixed table height to be set
+     * - button: when scrolling to the end of the table, a button is shown that can be clicked to load the next page of data
+     *
+     * @default "select"
+     */
+    type?: PaginationType;
+    /**
+     * Whether the data is currently loading after changing the current page.
+     * Should only be used if pagination is async.
+     */
+    loading?: Ref<boolean>;
+};
+export type PaginationState = {
+    /**
+     * Current page number. First page = 1.
+     */
+    current: number;
+    /**
+     * Total number of pages.
+     */
+    pages: number;
+    /**
+     * How many entries should be displayed per page.
+     */
+    pageSize: number;
+};
+export type PaginationType = "select" | "lazy" | "button";

package/dist/components/OnyxDataGrid/features/renderer.d.ts

@@ -0,0 +1,71 @@
+import { OnyxDateFormatOptions, OnyxNumberFormatOptions } from '../../../i18n/index.js';
+import { OnyxIconProps } from '../../OnyxIcon/types.js';
+import { DataGridEntry } from '../types.js';
+import { DataGridFeatureDescription, TypeRenderer, TypeRenderMap } from './index.js';
+export declare const FALLBACK_RENDER_VALUE = "-";
+/**
+ * Allows for creating `TypeRenderer` with typed options.
+ * These options are then made available via the column configuration.
+ *
+ * While typeRenderer can be defined without this helper, they cannot define any options.
+ */
+export declare const createTypeRenderer: <TOptions = undefined, TEntry extends DataGridEntry = DataGridEntry>(typeRenderer: TypeRenderer<TEntry, TOptions>) => Readonly<TypeRenderer<TEntry, TOptions>>;
+export type NumberCellOptions = {
+    format?: OnyxNumberFormatOptions;
+    /**
+     * Fallback value to display when the value is undefined or invalid.
+     * Defaults to "-" if not provided.
+     */
+    fallback?: string;
+};
+export declare const numberFormatter: <TEntry extends DataGridEntry>(value: TEntry[keyof TEntry] | undefined, opts?: NumberCellOptions) => string;
+export declare const NUMBER_RENDERER: Readonly<TypeRenderer<DataGridEntry, NumberCellOptions>>;
+export type StringCellOptions = {
+    /**
+     * Fallback value to display when the value is undefined.
+     * Defaults to "-" if not provided.
+     */
+    fallback?: string;
+};
+export declare const stringFormatter: <TEntry extends DataGridEntry>(value: TEntry[keyof TEntry] | undefined, opts?: StringCellOptions) => string;
+export declare const STRING_RENDERER: Readonly<TypeRenderer<DataGridEntry, StringCellOptions>>;
+export type DateCellOptions = {
+    format?: OnyxDateFormatOptions;
+    /**
+     * Fallback value to display when the value is undefined or invalid.
+     * Defaults to "-" if not provided.
+     */
+    fallback?: string;
+};
+export declare const dateFormatter: <TEntry extends DataGridEntry>(value: TEntry[keyof TEntry] | undefined, opts?: DateCellOptions) => string;
+export declare const DATE_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
+export declare const DATETIME_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
+export declare const TIME_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
+export declare const TIMESTAMP_RENDERER: Readonly<TypeRenderer<DataGridEntry, DateCellOptions>>;
+export declare const SKELETON_RENDERER: Readonly<TypeRenderer<DataGridEntry, StringCellOptions>>;
+export type BooleanCellOptions = {
+    /**
+     * Icon to display when the value is truthy.
+     */
+    truthy?: BooleanCellIconOptions;
+    /**
+     * Icon to display when the value is falsy.
+     */
+    falsy?: BooleanCellIconOptions;
+};
+export type BooleanCellIconOptions = Partial<OnyxIconProps> & {
+    /**
+     * Label to display (visually hidden) for e.g. screen readers.
+     *
+     * @default "Yes" / "No" label depending on the current locale
+     */
+    label?: string;
+};
+export declare const BOOLEAN_RENDERER: Readonly<TypeRenderer<DataGridEntry, BooleanCellOptions>>;
+export declare const createRenderer: <TEntry extends DataGridEntry>(features: DataGridFeatureDescription<TEntry, TypeRenderMap<TEntry>, symbol>[]) => {
+    /**
+     * Returns a renderer for any given component and type.
+     * Uses the fallbackRenderer if necessary.
+     */
+    getFor: <TComponent extends "cell" | "header", TRenderer extends NonNullable<TypeRenderer<TEntry, any>[TComponent]>>(component: TComponent, type?: PropertyKey) => TRenderer;
+};

package/dist/components/OnyxDataGrid/features/resizing/resizing.d.ts

@@ -0,0 +1,51 @@
+import { DataGridEntry } from '../../types.js';
+import { InternalColumnConfig } from '../index.js';
+import { ResizingOptions } from './types.js';
+export declare const RESIZING_FEATURE: unique symbol;
+export declare const FILLER_COLUMN: unique symbol;
+export declare const useResizing: <TEntry extends DataGridEntry>(options?: ResizingOptions<TEntry>) => (ctx: import('../index.js').DataGridFeatureContext) => {
+    name: symbol;
+    modifyColumns: {
+        func: (cols: Readonly<InternalColumnConfig<TEntry>[]>) => InternalColumnConfig<TEntry>[];
+    };
+    scrollContainerAttributes: () => {
+        ref: (el: Element | import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import('vue').ComponentProvideOptions>, {}, {}, "", {}, any> | null) => void;
+    };
+    typeRenderer: {
+        /**
+         * The filler column stretches the remaining space in case the column widths are smaller than the table's intended width.
+         */
+        [FILLER_COLUMN]: {
+            header: {
+                thAttributes: {
+                    class: string;
+                    "aria-hidden": true;
+                };
+                component: () => null;
+            };
+            cell: {
+                tdAttributes: {
+                    class: string;
+                    "aria-hidden": true;
+                };
+                component: () => null;
+            };
+        };
+    };
+    header: {
+        wrapper: (cols: InternalColumnConfig<any, any>, i: number, { length }: InternalColumnConfig<any, any>[]) => (_: any, { slots }: Omit<{
+            attrs: {
+                [x: string]: unknown;
+            };
+            slots: Readonly<{
+                [name: string]: import('vue').Slot<any> | undefined;
+            }>;
+            emit: (event: string, ...args: any[]) => void;
+            expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed) => void;
+        }, "expose">) => (import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }> | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+            [key: string]: any;
+        }>[] | undefined)[] | undefined;
+    };
+};

package/dist/components/OnyxDataGrid/features/resizing/types.d.ts

@@ -0,0 +1,7 @@
+import { DataGridEntry } from '../../types.js';
+import { DataGridFeatureOptions } from '../index.js';
+/**
+ * The configuration options for the resizing feature in the OnyxDataGrid component.
+ * Includes settings for the individual columns and general resizing behavior.
+ */
+export type ResizingOptions<TEntry extends DataGridEntry> = DataGridFeatureOptions<TEntry, object>;

package/dist/components/OnyxDataGrid/features/selection/selection.d.ts

@@ -0,0 +1,17 @@
+import { Ref } from 'vue';
+import { DataGridEntry } from '../../types.js';
+import { SelectionOptions, SelectionState } from './types.js';
+export declare const SELECTION_FEATURE: unique symbol;
+export declare const SELECTION_MUTATION_ORDER = 1000;
+export declare const useSelection: <TEntry extends DataGridEntry>(options?: SelectionOptions) => (ctx: import('../index.js').DataGridFeatureContext) => {
+    name: symbol;
+    watch: (Readonly<Ref<boolean, boolean>> | import('vue').ComputedRef<(column?: PropertyKey) => boolean> | Ref<SelectionState, SelectionState>)[];
+    modifyColumns: import('../../../../utils/feature.js').SingleOrderableMapping<import('../index.js').InternalColumnConfig<TEntry, any>[], import('../index.js').InternalColumnConfig<TEntry, any>[], readonly import('../index.js').InternalColumnConfig<TEntry, any>[]>;
+    mutation: {
+        func: (rows: Readonly<any>[]) => Readonly<any>[];
+        order: number;
+    };
+    typeRenderer: {
+        [x: string]: Readonly<import('../index.js').TypeRenderer<any, object>>;
+    };
+};