bitboss-ui 2.1.127 → 2.1.129

package/dist/components/BbTable/types.d.ts

@@ -71,6 +71,28 @@ export type BbTableColumn<Item = any> = BaseColumn<Item> & {
      * Defines the classes to be passed to the `<th>`.
      */
     thClass?: Classes;
+    /**
+     * Freezes the column to a fixed width (numbers are treated as px). When
+     * omitted the column syncs its width to the parent table's matching track.
+     */
+    width?: number | string;
+    /**
+     * For a nested table, where this column snaps onto the parent's grid. The
+     * parent's columns form snap points where `select` occupies `[0, 1]`, data
+     * column `k` occupies `[k + 1, k + 2]` and `actions` occupies `[N + 1, N + 2]`.
+     *
+     * - A single number is a start snap point that takes one parent track, e.g.
+     *   `2` → `[2, 3]`. It may skip ahead (`5` jumps straight to the sixth track),
+     *   and the next column resumes from where it ends.
+     * - A `[start, end]` pair snaps between two points; the width is the sum of
+     *   the fractional parent tracks it covers, so `[3, 4.5]` is the full fourth
+     *   track plus half of the fifth. `end` of `-1` runs to the end of the data
+     *   region.
+     *
+     * When omitted the column chains from the previous column's end to the next
+     * whole snap point (a one-to-one inheritance by index).
+     */
+    snap?: number | [start: number, end: number];
 };
 export type BbTableProps<Item = any> = {
     /**
@@ -90,6 +112,22 @@ export type BbTableProps<Item = any> = {
      * Text alignment of the columns.
      */
     align?: 'left' | 'center' | 'right';
+    /**
+     * Stable id for this table's width context. When omitted a unique id is
+     * generated. Nested tables use the nearest ancestor id to inherit widths.
+     */
+    id?: string;
+    /**
+     * Controls whether unfrozen columns inherit their width from an ancestor
+     * table's matching track, accounting for `select`/`actions` columns.
+     * - `true` (the default): inherit from the nearest ancestor table.
+     * - `false`: do not inherit.
+     * - a table id (string): inherit from the specific ancestor in the chain with
+     *   that id rather than the immediate parent. Use this when an intermediate
+     *   table has a different column count, so the extra columns would otherwise
+     *   misalign against it.
+     */
+    inheritColumnWidths?: boolean | string;
     /**
      * Boolean that defines whether to display a "Select all" checkbox.
      */

package/dist/composables/useTableWidthContext.d.ts

@@ -0,0 +1,42 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * A single table's entry in the shared width registry.
+ *
+ * `tracks` is keyed, not indexed, so structural columns participate too:
+ * `'select'`, the data-column index (`'0'`, `'1'`, …) and `'actions'`.
+ */
+export interface TableWidthNode {
+    id: string;
+    parentId: string | null;
+    /** Measured track widths as CSS lengths, keyed by track id. */
+    tracks: Record<string, string>;
+}
+export type TableWidthRegistry = Map<string, TableWidthNode>;
+export interface UseTableWidthContextOptions {
+    /** Explicit table id. When omitted a stable unique id is generated. */
+    id?: MaybeRefOrGetter<string | undefined>;
+    /** This table's container element; used to find the parent table in the DOM. */
+    container: MaybeRefOrGetter<HTMLElement | null | undefined>;
+    /**
+     * Id of a specific ancestor table to inherit from. When set, parent discovery
+     * walks the whole DOM ancestor chain for a table with this id rather than
+     * stopping at the nearest one. When omitted, the nearest ancestor table is
+     * used. A requested id that is not found in the chain yields no parent.
+     */
+    inheritFrom?: MaybeRefOrGetter<string | undefined>;
+}
+export declare function useTableWidthContext(options: UseTableWidthContextOptions): {
+    id: import('vue').ComputedRef<string>;
+    parentId: import('vue').Ref<string | null, string | null>;
+    parentNode: import('vue').ComputedRef<TableWidthNode | null>;
+    parentHasTrack: (key: string) => boolean;
+    parentVar: (key: string, fallback?: string) => string;
+    node: {
+        id: string;
+        parentId: string | null;
+        tracks: Record<string, string>;
+    };
+    registry: TableWidthRegistry;
+    setTracks: (tracks: Record<string, string>) => void;
+    cssVars: import('vue').ComputedRef<Record<string, string>>;
+};