@entifix/react-controls 0.1.0-0

package/dist/ui/organisms/entity-table/entity-table.types.d.ts

@@ -0,0 +1,126 @@
+import type { BulkOutcome, EntifixError, Entity, EntityConstructor, EntityFieldDescriptor, EntityId, EntityMetadataDocument, EntitySelection, EntitySorting, FilterGroup } from '@entifix/core';
+import type { ReactNode } from 'react';
+/**
+ * A column as the table finally renders it: the metadata descriptor plus the
+ * per-column overrides a caller supplied through an `<EntityColumn>` slot.
+ */
+export interface EntityTableColumn<TEntity extends Entity> extends EntityFieldDescriptor {
+    /** Replaces the default header text. */
+    header?: ReactNode;
+    /** Replaces the default `CellValue` rendering for this column. */
+    render?: (item: TEntity) => ReactNode;
+    /** True when the column has no backing entity member (slot-only column). */
+    virtual?: boolean;
+}
+/** Breakpoint at and above which the table renders as a grid, not as cards. */
+export type EntityTablePivotBreakpoint = 'sm' | 'md' | 'lg';
+export interface EntityTableProps<TEntity extends Entity> {
+    /** Metadata source. Columns, labels, types and the filter/sort controls all
+     *  derive from this constructor's accessors. */
+    entityConstructor: EntityConstructor<TEntity>;
+    isLoading: boolean;
+    /**
+     * What holds the table's shape during the first load.
+     *
+     * `true` (the default) renders the built-in placeholder, which is derived from
+     * the table's own resolved geometry — one shimmer cell per visible column, so
+     * the swap to real rows shifts nothing. A node replaces that default; `false`
+     * renders no placeholder at all.
+     *
+     * Only the *first* load is held this way. A refetch that already has rows
+     * keeps them and marks the region busy instead — replacing populated rows with
+     * shimmer on every pagination click is a grey flash, not a loading state.
+     */
+    skeleton?: boolean | ReactNode;
+    /**
+     * The failure of the last load, if it failed.
+     *
+     * A listing that renders an empty table when the service is unreachable tells
+     * the user their catalog is empty — the one thing they must not conclude. So
+     * this is rendered as an alert, and it also changes the empty message.
+     *
+     * It arrives for free from `useDataLoading`, whose whole state is spread into
+     * this component.
+     */
+    error?: EntifixError;
+    items: ReadonlyArray<TEntity>;
+    totalItems: number;
+    currentPage: number;
+    pageSize: number;
+    onPageChange: (newPage: number) => void;
+    onPageSizeChange?: (newPageSize: number) => void;
+    /**
+     * Builds the link to a row's record. Supplied as a function rather than the
+     * table routing by itself: this package must not depend on a router, so the
+     * caller (a shell page, which does know one) owns the URL shape.
+     *
+     * Omit it and the actions column is not rendered at all.
+     */
+    hrefFor?: (id: EntityId) => string;
+    /** Link to the create form. Omit and no `New` action is rendered. */
+    newHref?: string;
+    /**
+     * Picks a row instead of navigating to it — how a link picker reuses this
+     * table as its browse dialog.
+     *
+     * Takes precedence over {@link hrefFor}: inside a picker the user is choosing
+     * a value, and offering to navigate away from the form they are editing is the
+     * wrong affordance. Either one renders the actions column.
+     */
+    onSelect?: (item: TEntity) => void;
+    /** Scope for persisted personalization. Defaults to the entity's key. */
+    preferencesKey?: string;
+    /** Hide the toolbar (columns, filters, sorting) — a bare listing. */
+    showControls?: boolean;
+    /** Viewport width at which rows stop pivoting into cards. Default `md`. */
+    pivotBreakpoint?: EntityTablePivotBreakpoint;
+    /** The filtering currently applied, seeding the filter panel so it shows
+     *  what is in effect rather than an empty form. */
+    filtering?: FilterGroup<TEntity>;
+    /** The sorting currently applied, seeding the sort panel. */
+    sorting?: EntitySorting<TEntity>;
+    /** Notified when the filter panel is **applied** — not while it is edited, so
+     *  the value can feed a load request directly. */
+    onFilteringChange?: (filtering: FilterGroup<TEntity>) => void;
+    /** Notified when the sort panel is applied. */
+    onSortingChange?: (sorting: EntitySorting<TEntity>) => void;
+    /**
+     * The rows a collection-bound action would act on.
+     *
+     * **Controlled from above the table**, exactly as `filtering` and `sorting`
+     * are, and for the same reason plus one more: a selection has to survive
+     * pagination, and the page owns the pager. A selection held inside the table
+     * would be reset by the very navigation the user performs to add to it.
+     *
+     * Omit it and no selection column is rendered — a listing that is only read
+     * gains nothing from a column of empty boxes.
+     */
+    selection?: EntitySelection<TEntity>;
+    onSelectionChange?: (selection: EntitySelection<TEntity>) => void;
+    /**
+     * What this caller may do with the entity, as the service decided it.
+     *
+     * The same document `EntityForm` takes. The table reads only the
+     * `collection`-bound half of `useCases` — the entity-bound verbs belong to a
+     * record, and a row's own overflow menu is fed from the
+     * `context-dependent` ones.
+     *
+     * Absent keeps the pre-ADR-0026 behaviour: no bulk bar and no row menu, which
+     * is what every un-migrated call site renders today.
+     */
+    metadata?: EntityMetadataDocument;
+    isMetadataLoading?: boolean;
+    /** Runs a `collection`-bound verb over {@link selection}. */
+    onBulkUseCase?: (key: string, selection: EntitySelection<TEntity>) => void;
+    /** Runs an `entity`-bound, `context-dependent` verb on one row. */
+    onUseCase?: (key: string, item: TEntity) => void;
+    /** The outcome of the last bulk run, rendered per row until dismissed. */
+    bulkOutcomes?: readonly BulkOutcome[];
+    onBulkDismiss?: () => void;
+    onBulkRetry?: (ids: EntityId[]) => void;
+    /** A bulk run is in flight — every verb is disabled while it is. */
+    isBulkRunning?: boolean;
+    /** Customization slots — see `entity-table-slots`. */
+    children?: ReactNode;
+}
+//# sourceMappingURL=entity-table.types.d.ts.map

package/dist/ui/organisms/entity-table/entity-table.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-table.types.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-table/entity-table.types.ts"],"names":[],"mappings":"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"}

package/dist/ui/organisms/entity-table/entity-table.types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=entity-table.types.js.map

package/dist/ui/organisms/entity-table/entity-table.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-table/entity-table.types.ts"],"sourcesContent":["import type {\n  BulkOutcome,\n  EntifixError,\n  Entity,\n  EntityConstructor,\n  EntityFieldDescriptor,\n  EntityId,\n  EntityMetadataDocument,\n  EntitySelection,\n  EntitySorting,\n  FilterGroup,\n} from '@entifix/core';\nimport type { ReactNode } from 'react';\n\n/**\n * A column as the table finally renders it: the metadata descriptor plus the\n * per-column overrides a caller supplied through an `<EntityColumn>` slot.\n */\nexport interface EntityTableColumn<\n  TEntity extends Entity,\n> extends EntityFieldDescriptor {\n  /** Replaces the default header text. */\n  header?: ReactNode;\n  /** Replaces the default `CellValue` rendering for this column. */\n  render?: (item: TEntity) => ReactNode;\n  /** True when the column has no backing entity member (slot-only column). */\n  virtual?: boolean;\n}\n\n/** Breakpoint at and above which the table renders as a grid, not as cards. */\nexport type EntityTablePivotBreakpoint = 'sm' | 'md' | 'lg';\n\nexport interface EntityTableProps<TEntity extends Entity> {\n  /** Metadata source. Columns, labels, types and the filter/sort controls all\n   *  derive from this constructor's accessors. */\n  entityConstructor: EntityConstructor<TEntity>;\n\n  isLoading: boolean;\n  /**\n   * What holds the table's shape during the first load.\n   *\n   * `true` (the default) renders the built-in placeholder, which is derived from\n   * the table's own resolved geometry — one shimmer cell per visible column, so\n   * the swap to real rows shifts nothing. A node replaces that default; `false`\n   * renders no placeholder at all.\n   *\n   * Only the *first* load is held this way. A refetch that already has rows\n   * keeps them and marks the region busy instead — replacing populated rows with\n   * shimmer on every pagination click is a grey flash, not a loading state.\n   */\n  skeleton?: boolean | ReactNode;\n  /**\n   * The failure of the last load, if it failed.\n   *\n   * A listing that renders an empty table when the service is unreachable tells\n   * the user their catalog is empty — the one thing they must not conclude. So\n   * this is rendered as an alert, and it also changes the empty message.\n   *\n   * It arrives for free from `useDataLoading`, whose whole state is spread into\n   * this component.\n   */\n  error?: EntifixError;\n  items: ReadonlyArray<TEntity>;\n  totalItems: number;\n  currentPage: number;\n  pageSize: number;\n  onPageChange: (newPage: number) => void;\n  onPageSizeChange?: (newPageSize: number) => void;\n\n  /**\n   * Builds the link to a row's record. Supplied as a function rather than the\n   * table routing by itself: this package must not depend on a router, so the\n   * caller (a shell page, which does know one) owns the URL shape.\n   *\n   * Omit it and the actions column is not rendered at all.\n   */\n  hrefFor?: (id: EntityId) => string;\n  /** Link to the create form. Omit and no `New` action is rendered. */\n  newHref?: string;\n\n  /**\n   * Picks a row instead of navigating to it — how a link picker reuses this\n   * table as its browse dialog.\n   *\n   * Takes precedence over {@link hrefFor}: inside a picker the user is choosing\n   * a value, and offering to navigate away from the form they are editing is the\n   * wrong affordance. Either one renders the actions column.\n   */\n  onSelect?: (item: TEntity) => void;\n\n  /** Scope for persisted personalization. Defaults to the entity's key. */\n  preferencesKey?: string;\n  /** Hide the toolbar (columns, filters, sorting) — a bare listing. */\n  showControls?: boolean;\n  /** Viewport width at which rows stop pivoting into cards. Default `md`. */\n  pivotBreakpoint?: EntityTablePivotBreakpoint;\n\n  /** The filtering currently applied, seeding the filter panel so it shows\n   *  what is in effect rather than an empty form. */\n  filtering?: FilterGroup<TEntity>;\n  /** The sorting currently applied, seeding the sort panel. */\n  sorting?: EntitySorting<TEntity>;\n\n  /** Notified when the filter panel is **applied** — not while it is edited, so\n   *  the value can feed a load request directly. */\n  onFilteringChange?: (filtering: FilterGroup<TEntity>) => void;\n  /** Notified when the sort panel is applied. */\n  onSortingChange?: (sorting: EntitySorting<TEntity>) => void;\n\n  /**\n   * The rows a collection-bound action would act on.\n   *\n   * **Controlled from above the table**, exactly as `filtering` and `sorting`\n   * are, and for the same reason plus one more: a selection has to survive\n   * pagination, and the page owns the pager. A selection held inside the table\n   * would be reset by the very navigation the user performs to add to it.\n   *\n   * Omit it and no selection column is rendered — a listing that is only read\n   * gains nothing from a column of empty boxes.\n   */\n  selection?: EntitySelection<TEntity>;\n  onSelectionChange?: (selection: EntitySelection<TEntity>) => void;\n\n  /**\n   * What this caller may do with the entity, as the service decided it.\n   *\n   * The same document `EntityForm` takes. The table reads only the\n   * `collection`-bound half of `useCases` — the entity-bound verbs belong to a\n   * record, and a row's own overflow menu is fed from the\n   * `context-dependent` ones.\n   *\n   * Absent keeps the pre-ADR-0026 behaviour: no bulk bar and no row menu, which\n   * is what every un-migrated call site renders today.\n   */\n  metadata?: EntityMetadataDocument;\n  isMetadataLoading?: boolean;\n\n  /** Runs a `collection`-bound verb over {@link selection}. */\n  onBulkUseCase?: (key: string, selection: EntitySelection<TEntity>) => void;\n  /** Runs an `entity`-bound, `context-dependent` verb on one row. */\n  onUseCase?: (key: string, item: TEntity) => void;\n\n  /** The outcome of the last bulk run, rendered per row until dismissed. */\n  bulkOutcomes?: readonly BulkOutcome[];\n  onBulkDismiss?: () => void;\n  onBulkRetry?: (ids: EntityId[]) => void;\n  /** A bulk run is in flight — every verb is disabled while it is. */\n  isBulkRunning?: boolean;\n\n  /** Customization slots — see `entity-table-slots`. */\n  children?: ReactNode;\n}\n"],"names":[],"mappings":"AAgCA,WAuHC"}

package/dist/ui/organisms/entity-table/index.d.ts

@@ -0,0 +1,5 @@
+export * from './entity-table.js';
+export * from './entity-table.types.js';
+export * from './entity-table-slots.js';
+export * from './use-entity-table-columns.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/organisms/entity-table/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-table/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}

package/dist/ui/organisms/entity-table/index.js

@@ -0,0 +1,6 @@
+export * from './entity-table.js';
+export * from './entity-table.types.js';
+export * from './entity-table-slots.js';
+export * from './use-entity-table-columns.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/organisms/entity-table/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-table/index.ts"],"sourcesContent":["export * from './entity-table.js';\nexport * from './entity-table.types.js';\nexport * from './entity-table-slots.js';\nexport * from './use-entity-table-columns.js';\n"],"names":[],"mappings":"AAAA,cAAc,oBAAoB;AAClC,cAAc,0BAA0B;AACxC,cAAc,0BAA0B;AACxC,cAAc,gCAAgC"}

package/dist/ui/organisms/entity-table/use-entity-table-columns.d.ts

@@ -0,0 +1,29 @@
+import { type Entity, type EntityConstructor } from '@entifix/core';
+import type { ColumnPersonalization } from '../../molecules/column-settings/index.js';
+import type { EntityTableColumn } from './entity-table.types.js';
+import type { EntityColumnProps } from './entity-table-slots.js';
+/**
+ * The whole column pipeline as a pure function — metadata descriptors, then
+ * slot overrides, then the user's stored layout. Kept separate from the hook so
+ * the resolution rules can be reasoned about (and tested) without React.
+ */
+export declare function resolveEntityTableColumns<TEntity extends Entity>(described: Array<EntityTableColumn<TEntity>>, slotColumns: Array<EntityColumnProps<TEntity>>, personalization: ColumnPersonalization): {
+    columns: Array<EntityTableColumn<TEntity>>;
+    visibleColumns: Array<EntityTableColumn<TEntity>>;
+    hidden: string[];
+};
+export interface UseEntityTableColumnsResult<TEntity extends Entity> {
+    /** Every column, in the user's order — what the settings popover lists. */
+    columns: Array<EntityTableColumn<TEntity>>;
+    /** The subset actually rendered. */
+    visibleColumns: Array<EntityTableColumn<TEntity>>;
+    hidden: string[];
+    personalization: ColumnPersonalization;
+    setPersonalization: (next: ColumnPersonalization) => void;
+}
+/**
+ * Resolves the columns a table renders: entity metadata, then slot overrides,
+ * then the user's persisted layout.
+ */
+export declare function useEntityTableColumns<TEntity extends Entity>(entityConstructor: EntityConstructor<TEntity>, slotColumns: Array<EntityColumnProps<TEntity>>, sample: TEntity | undefined, preferenceKey: string): UseEntityTableColumnsResult<TEntity>;
+//# sourceMappingURL=use-entity-table-columns.d.ts.map

package/dist/ui/organisms/entity-table/use-entity-table-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-table-columns.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/entity-table/use-entity-table-columns.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,MAAM,EACX,KAAK,iBAAiB,EACvB,MAAM,eAAe,CAAC;AAKvB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACtF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAyEjE;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,SAAS,MAAM,EAC9D,SAAS,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,EAC5C,WAAW,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,EAC9C,eAAe,EAAE,qBAAqB,GACrC;IACD,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3C,cAAc,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAYA;AAED,MAAM,WAAW,2BAA2B,CAAC,OAAO,SAAS,MAAM;IACjE,2EAA2E;IAC3E,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC3C,oCAAoC;IACpC,cAAc,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAClD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,eAAe,EAAE,qBAAqB,CAAC;IACvC,kBAAkB,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,CAAC;CAC3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,SAAS,MAAM,EAC1D,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,WAAW,EAAE,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,EAC9C,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,aAAa,EAAE,MAAM,GACpB,2BAA2B,CAAC,OAAO,CAAC,CAmCtC"}

package/dist/ui/organisms/entity-table/use-entity-table-columns.js

@@ -0,0 +1,103 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { describeEntityColumns } from '@entifix/core';
+import { useMemo } from 'react';
+import { useLocalizedDescriptors } from '../../../i18n/index.js';
+import { useUiPreference } from '../../../preferences/index.js';
+const EMPTY_PERSONALIZATION = {};
+/**
+ * Applies `<EntityColumn>` overrides on top of the metadata descriptors, and
+ * appends a virtual column for any slot naming a member the entity does not
+ * have (a computed column).
+ */ function mergeSlots(descriptors, slotColumns) {
+    const merged = descriptors.map((descriptor)=>{
+        const slot = slotColumns.find((entry)=>entry.field === descriptor.name);
+        if (!slot) return descriptor;
+        const { field: _field } = slot, overrides = _object_without_properties_loose(slot, [
+            "field"
+        ]);
+        return _extends({}, descriptor, Object.fromEntries(Object.entries(overrides).filter(([, value])=>value !== undefined)));
+    });
+    const virtual = slotColumns.filter((slot)=>!descriptors.some((entry)=>entry.name === slot.field)).map((slot, index)=>{
+        var _slot_label, _slot_type, _slot_sortable, _slot_filterable, _slot_order;
+        return {
+            name: slot.field,
+            key: slot.field,
+            label: (_slot_label = slot.label) != null ? _slot_label : slot.field,
+            type: (_slot_type = slot.type) != null ? _slot_type : 'string',
+            sortable: (_slot_sortable = slot.sortable) != null ? _slot_sortable : false,
+            filterable: (_slot_filterable = slot.filterable) != null ? _slot_filterable : false,
+            order: (_slot_order = slot.order) != null ? _slot_order : descriptors.length + index,
+            readonly: false,
+            required: false,
+            linkLabelProperty: 'name',
+            linkSearchProperty: 'name',
+            linkSerialization: 'id',
+            // A slot-only column has no accessor, so there is nothing for a copy to
+            // reset — the value is computed from members that are cloned themselves.
+            resetOnClone: false,
+            header: slot.header,
+            render: slot.render,
+            virtual: true
+        };
+    });
+    return [
+        ...merged,
+        ...virtual
+    ].sort((left, right)=>left.order - right.order);
+}
+/**
+ * Reorders columns per the stored personalization. Names the user never saw
+ * (added to the entity after the layout was saved) keep their default position
+ * at the end instead of vanishing, and stale names in the stored order are
+ * dropped — so a saved layout degrades rather than breaks.
+ */ function applyOrder(columns, order) {
+    if (!order || order.length === 0) return columns;
+    const ranked = order.map((name)=>columns.find((column)=>column.name === name)).filter((column)=>!!column);
+    const remaining = columns.filter((column)=>!order.includes(column.name));
+    return [
+        ...ranked,
+        ...remaining
+    ];
+}
+/**
+ * The whole column pipeline as a pure function — metadata descriptors, then
+ * slot overrides, then the user's stored layout. Kept separate from the hook so
+ * the resolution rules can be reasoned about (and tested) without React.
+ */ export function resolveEntityTableColumns(described, slotColumns, personalization) {
+    var _personalization_hidden;
+    const columns = applyOrder(mergeSlots(described, slotColumns), personalization.order);
+    const hidden = (_personalization_hidden = personalization.hidden) != null ? _personalization_hidden : [];
+    return {
+        columns,
+        visibleColumns: columns.filter((column)=>!hidden.includes(column.name)),
+        hidden
+    };
+}
+/**
+ * Resolves the columns a table renders: entity metadata, then slot overrides,
+ * then the user's persisted layout.
+ */ export function useEntityTableColumns(entityConstructor, slotColumns, sample, preferenceKey) {
+    const { value: personalization, setValue: setPersonalization } = useUiPreference(preferenceKey, EMPTY_PERSONALIZATION);
+    const metadata = useMemo(()=>describeEntityColumns(entityConstructor, sample), [
+        entityConstructor,
+        sample
+    ]);
+    // Before slots merge, so an `<EntityColumn label>` override still wins over
+    // the entity's own translated label.
+    const described = useLocalizedDescriptors(metadata);
+    // Not memoized: `slotColumns` is rebuilt from `children` on every render, so
+    // any dependency list would miss every time. The work is a few array passes
+    // over a handful of columns — cheaper than the comparison would be.
+    const { columns, visibleColumns, hidden } = resolveEntityTableColumns(described, slotColumns, personalization);
+    return {
+        columns,
+        visibleColumns,
+        hidden,
+        personalization,
+        setPersonalization
+    };
+}
+
+//# sourceMappingURL=use-entity-table-columns.js.map

package/dist/ui/organisms/entity-table/use-entity-table-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/entity-table/use-entity-table-columns.ts"],"sourcesContent":["'use client';\n\nimport {\n  describeEntityColumns,\n  type Entity,\n  type EntityConstructor,\n} from '@entifix/core';\nimport { useMemo } from 'react';\n\nimport { useLocalizedDescriptors } from '../../../i18n/index.js';\nimport { useUiPreference } from '../../../preferences/index.js';\nimport type { ColumnPersonalization } from '../../molecules/column-settings/index.js';\nimport type { EntityTableColumn } from './entity-table.types.js';\nimport type { EntityColumnProps } from './entity-table-slots.js';\n\nconst EMPTY_PERSONALIZATION: ColumnPersonalization = {};\n\n/**\n * Applies `<EntityColumn>` overrides on top of the metadata descriptors, and\n * appends a virtual column for any slot naming a member the entity does not\n * have (a computed column).\n */\nfunction mergeSlots<TEntity extends Entity>(\n  descriptors: Array<EntityTableColumn<TEntity>>,\n  slotColumns: Array<EntityColumnProps<TEntity>>,\n): Array<EntityTableColumn<TEntity>> {\n  const merged = descriptors.map(descriptor => {\n    const slot = slotColumns.find(entry => entry.field === descriptor.name);\n    if (!slot) return descriptor;\n    const { field: _field, ...overrides } = slot;\n    return {\n      ...descriptor,\n      ...Object.fromEntries(\n        Object.entries(overrides).filter(([, value]) => value !== undefined),\n      ),\n    } as EntityTableColumn<TEntity>;\n  });\n\n  const virtual = slotColumns\n    .filter(slot => !descriptors.some(entry => entry.name === slot.field))\n    .map<EntityTableColumn<TEntity>>((slot, index) => ({\n      name: slot.field,\n      key: slot.field,\n      label: slot.label ?? slot.field,\n      type: slot.type ?? 'string',\n      sortable: slot.sortable ?? false,\n      filterable: slot.filterable ?? false,\n      order: slot.order ?? descriptors.length + index,\n      readonly: false,\n      required: false,\n      linkLabelProperty: 'name',\n      linkSearchProperty: 'name',\n      linkSerialization: 'id',\n      // A slot-only column has no accessor, so there is nothing for a copy to\n      // reset — the value is computed from members that are cloned themselves.\n      resetOnClone: false,\n      header: slot.header,\n      render: slot.render,\n      virtual: true,\n    }));\n\n  return [...merged, ...virtual].sort(\n    (left, right) => left.order - right.order,\n  );\n}\n\n/**\n * Reorders columns per the stored personalization. Names the user never saw\n * (added to the entity after the layout was saved) keep their default position\n * at the end instead of vanishing, and stale names in the stored order are\n * dropped — so a saved layout degrades rather than breaks.\n */\nfunction applyOrder<TEntity extends Entity>(\n  columns: Array<EntityTableColumn<TEntity>>,\n  order: string[] | undefined,\n): Array<EntityTableColumn<TEntity>> {\n  if (!order || order.length === 0) return columns;\n\n  const ranked = order\n    .map(name => columns.find(column => column.name === name))\n    .filter((column): column is EntityTableColumn<TEntity> => !!column);\n  const remaining = columns.filter(column => !order.includes(column.name));\n\n  return [...ranked, ...remaining];\n}\n\n/**\n * The whole column pipeline as a pure function — metadata descriptors, then\n * slot overrides, then the user's stored layout. Kept separate from the hook so\n * the resolution rules can be reasoned about (and tested) without React.\n */\nexport function resolveEntityTableColumns<TEntity extends Entity>(\n  described: Array<EntityTableColumn<TEntity>>,\n  slotColumns: Array<EntityColumnProps<TEntity>>,\n  personalization: ColumnPersonalization,\n): {\n  columns: Array<EntityTableColumn<TEntity>>;\n  visibleColumns: Array<EntityTableColumn<TEntity>>;\n  hidden: string[];\n} {\n  const columns = applyOrder(\n    mergeSlots(described, slotColumns),\n    personalization.order,\n  );\n  const hidden = personalization.hidden ?? [];\n\n  return {\n    columns,\n    visibleColumns: columns.filter(column => !hidden.includes(column.name)),\n    hidden,\n  };\n}\n\nexport interface UseEntityTableColumnsResult<TEntity extends Entity> {\n  /** Every column, in the user's order — what the settings popover lists. */\n  columns: Array<EntityTableColumn<TEntity>>;\n  /** The subset actually rendered. */\n  visibleColumns: Array<EntityTableColumn<TEntity>>;\n  hidden: string[];\n  personalization: ColumnPersonalization;\n  setPersonalization: (next: ColumnPersonalization) => void;\n}\n\n/**\n * Resolves the columns a table renders: entity metadata, then slot overrides,\n * then the user's persisted layout.\n */\nexport function useEntityTableColumns<TEntity extends Entity>(\n  entityConstructor: EntityConstructor<TEntity>,\n  slotColumns: Array<EntityColumnProps<TEntity>>,\n  sample: TEntity | undefined,\n  preferenceKey: string,\n): UseEntityTableColumnsResult<TEntity> {\n  const { value: personalization, setValue: setPersonalization } =\n    useUiPreference<ColumnPersonalization>(\n      preferenceKey,\n      EMPTY_PERSONALIZATION,\n    );\n\n  const metadata = useMemo(\n    () =>\n      describeEntityColumns(entityConstructor, sample) as Array<\n        EntityTableColumn<TEntity>\n      >,\n    [entityConstructor, sample],\n  );\n\n  // Before slots merge, so an `<EntityColumn label>` override still wins over\n  // the entity's own translated label.\n  const described = useLocalizedDescriptors(metadata);\n\n  // Not memoized: `slotColumns` is rebuilt from `children` on every render, so\n  // any dependency list would miss every time. The work is a few array passes\n  // over a handful of columns — cheaper than the comparison would be.\n  const { columns, visibleColumns, hidden } = resolveEntityTableColumns(\n    described,\n    slotColumns,\n    personalization,\n  );\n\n  return {\n    columns,\n    visibleColumns,\n    hidden,\n    personalization,\n    setPersonalization,\n  };\n}\n"],"names":["describeEntityColumns","useMemo","useLocalizedDescriptors","useUiPreference","EMPTY_PERSONALIZATION","mergeSlots","descriptors","slotColumns","merged","map","descriptor","slot","find","entry","field","name","_field","overrides","Object","fromEntries","entries","filter","value","undefined","virtual","some","index","key","label","type","sortable","filterable","order","length","readonly","required","linkLabelProperty","linkSearchProperty","linkSerialization","resetOnClone","header","render","sort","left","right","applyOrder","columns","ranked","column","remaining","includes","resolveEntityTableColumns","described","personalization","hidden","visibleColumns","useEntityTableColumns","entityConstructor","sample","preferenceKey","setValue","setPersonalization","metadata"],"mappings":"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"}

package/dist/ui/organisms/top-bar/index.d.ts

@@ -0,0 +1,2 @@
+export * from './top-bar.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/organisms/top-bar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/top-bar/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/ui/organisms/top-bar/index.js

@@ -0,0 +1,3 @@
+export * from './top-bar.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/organisms/top-bar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/top-bar/index.ts"],"sourcesContent":["export * from './top-bar.js';\n"],"names":[],"mappings":"AAAA,cAAc,eAAe"}

package/dist/ui/organisms/top-bar/top-bar.d.ts

@@ -0,0 +1,20 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+export type TopBarProps = ComponentPropsWithoutRef<'header'>;
+/**
+ * The application top bar: a thin, recessive band carrying identity on the left
+ * and actions on the right. Deliberately quiet — the workspace tab strip below
+ * it is where the eye goes. Compose it from the slots: `TopBar.Brand`,
+ * `TopBar.Context`, `TopBar.Actions`.
+ */
+export declare function TopBar({ className, children, ...props }: TopBarProps): import("react").JSX.Element;
+export declare namespace TopBar {
+    var Brand: ({ children, className }: SlotProps) => import("react").JSX.Element;
+    var Context: ({ children, className }: SlotProps) => import("react").JSX.Element;
+    var Actions: ({ children, className }: SlotProps) => import("react").JSX.Element;
+}
+interface SlotProps {
+    children: ReactNode;
+    className?: string;
+}
+export {};
+//# sourceMappingURL=top-bar.d.ts.map

package/dist/ui/organisms/top-bar/top-bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"top-bar.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/top-bar/top-bar.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIjE,MAAM,MAAM,WAAW,GAAG,wBAAwB,CAAC,QAAQ,CAAC,CAAC;AAE7D;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,WAAW,+BAYpE;yBAZe,MAAM;yCAmBkB,SAAS;2CAaP,SAAS;2CAST,SAAS;;AA3BnD,UAAU,SAAS;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/dist/ui/organisms/top-bar/top-bar.js

@@ -0,0 +1,43 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cn } from '../../utils/cn.js';
+/**
+ * The application top bar: a thin, recessive band carrying identity on the left
+ * and actions on the right. Deliberately quiet — the workspace tab strip below
+ * it is where the eye goes. Compose it from the slots: `TopBar.Brand`,
+ * `TopBar.Context`, `TopBar.Actions`.
+ */ export function TopBar(_0) {
+    let { className, children } = _0, props = _object_without_properties_loose(_0, [
+        "className",
+        "children"
+    ]);
+    return /*#__PURE__*/ _jsx("header", _extends({
+        className: cn('flex items-center gap-s border-b border-border bg-surface-elevated px-m py-2xs', className)
+    }, props, {
+        children: children
+    }));
+}
+function Brand({ children, className }) {
+    return /*#__PURE__*/ _jsx("div", {
+        className: cn('flex items-center gap-2xs text-step-1 font-semibold text-content', className),
+        children: children
+    });
+}
+function Context({ children, className }) {
+    return /*#__PURE__*/ _jsx("div", {
+        className: cn('text-step-sm text-content-muted', className),
+        children: children
+    });
+}
+/** Right-aligned cluster — search, notifications, the user menu. */ function Actions({ children, className }) {
+    return /*#__PURE__*/ _jsx("div", {
+        className: cn('ml-auto flex items-center gap-2xs', className),
+        children: children
+    });
+}
+TopBar.Brand = Brand;
+TopBar.Context = Context;
+TopBar.Actions = Actions;
+
+//# sourceMappingURL=top-bar.js.map

package/dist/ui/organisms/top-bar/top-bar.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/top-bar/top-bar.tsx"],"sourcesContent":["import type { ComponentPropsWithoutRef, ReactNode } from 'react';\n\nimport { cn } from '../../utils/cn.js';\n\nexport type TopBarProps = ComponentPropsWithoutRef<'header'>;\n\n/**\n * The application top bar: a thin, recessive band carrying identity on the left\n * and actions on the right. Deliberately quiet — the workspace tab strip below\n * it is where the eye goes. Compose it from the slots: `TopBar.Brand`,\n * `TopBar.Context`, `TopBar.Actions`.\n */\nexport function TopBar({ className, children, ...props }: TopBarProps) {\n  return (\n    <header\n      className={cn(\n        'flex items-center gap-s border-b border-border bg-surface-elevated px-m py-2xs',\n        className,\n      )}\n      {...props}\n    >\n      {children}\n    </header>\n  );\n}\n\ninterface SlotProps {\n  children: ReactNode;\n  className?: string;\n}\n\nfunction Brand({ children, className }: SlotProps) {\n  return (\n    <div\n      className={cn(\n        'flex items-center gap-2xs text-step-1 font-semibold text-content',\n        className,\n      )}\n    >\n      {children}\n    </div>\n  );\n}\n\nfunction Context({ children, className }: SlotProps) {\n  return (\n    <div className={cn('text-step-sm text-content-muted', className)}>\n      {children}\n    </div>\n  );\n}\n\n/** Right-aligned cluster — search, notifications, the user menu. */\nfunction Actions({ children, className }: SlotProps) {\n  return (\n    <div className={cn('ml-auto flex items-center gap-2xs', className)}>\n      {children}\n    </div>\n  );\n}\n\nTopBar.Brand = Brand;\nTopBar.Context = Context;\nTopBar.Actions = Actions;\n"],"names":["cn","TopBar","className","children","props","header","Brand","div","Context","Actions"],"mappings":";;;AAEA,SAASA,EAAE,QAAQ,oBAAoB;AAIvC;;;;;CAKC,GACD,OAAO,SAASC,OAAO,EAA8C;QAA9C,EAAEC,SAAS,EAAEC,QAAQ,EAAyB,OAApBC;;;;IAC/C,qBACE,KAACC;QACCH,WAAWF,GACT,kFACAE;OAEEE;kBAEHD;;AAGP;AAOA,SAASG,MAAM,EAAEH,QAAQ,EAAED,SAAS,EAAa;IAC/C,qBACE,KAACK;QACCL,WAAWF,GACT,oEACAE;kBAGDC;;AAGP;AAEA,SAASK,QAAQ,EAAEL,QAAQ,EAAED,SAAS,EAAa;IACjD,qBACE,KAACK;QAAIL,WAAWF,GAAG,mCAAmCE;kBACnDC;;AAGP;AAEA,kEAAkE,GAClE,SAASM,QAAQ,EAAEN,QAAQ,EAAED,SAAS,EAAa;IACjD,qBACE,KAACK;QAAIL,WAAWF,GAAG,qCAAqCE;kBACrDC;;AAGP;AAEAF,OAAOK,KAAK,GAAGA;AACfL,OAAOO,OAAO,GAAGA;AACjBP,OAAOQ,OAAO,GAAGA"}

package/dist/ui/organisms/wizard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './wizard.js';
+export * from './wizard.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ui/organisms/wizard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/wizard/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

package/dist/ui/organisms/wizard/index.js

@@ -0,0 +1,4 @@
+export * from './wizard.js';
+export * from './wizard.types.js';
+
+//# sourceMappingURL=index.js.map

package/dist/ui/organisms/wizard/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/ui/organisms/wizard/index.ts"],"sourcesContent":["export * from './wizard.js';\nexport * from './wizard.types.js';\n"],"names":[],"mappings":"AAAA,cAAc,cAAc;AAC5B,cAAc,oBAAoB"}

package/dist/ui/organisms/wizard/wizard.d.ts

@@ -0,0 +1,21 @@
+import type { WizardProps } from './wizard.types.js';
+/**
+ * A guided multi-step flow: the stepper, the active step's body, and the
+ * controls that move between them.
+ *
+ * **Presentational, and controlled from above.** It holds no step state, no
+ * draft and no router — `activeStep` is a prop and `onStepChange` reports a
+ * click, the same rule that made `hrefFor` a prop, so URL synchronisation stays
+ * the shell's job and this control can be told to render step four by a route,
+ * a workspace tab, or a Storybook arg without knowing which
+ * ([ADR 0045](../../../../../../../docs/adr/0045-the-wizard-a-step-graph-and-a-submit-that-hands-off.md)).
+ *
+ * ⚠️ **The stepper is an ordered list, not a tablist.** `TabStrip` is the
+ * nearest-looking thing in this package and is the wrong precedent: a
+ * `role="tablist"` tells assistive technology that the panels are siblings the
+ * user may choose between, and a wizard's steps are ordered and gated. So this
+ * is `<ol>`/`<li>` with `aria-current="step"`, and each step's status is
+ * announced rather than carried by colour alone.
+ */
+export declare function Wizard({ steps, activeStep, title, children, onNext, onFinish, onPrevious, onStepChange, canFinish, canAdvance, isSubmitting, recap, onDismissRecap, isLoading, skeleton, className, }: WizardProps): import("react").JSX.Element;
+//# sourceMappingURL=wizard.d.ts.map

package/dist/ui/organisms/wizard/wizard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wizard.d.ts","sourceRoot":"","sources":["../../../../src/ui/organisms/wizard/wizard.tsx"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAkB,MAAM,mBAAmB,CAAC;AAkCrE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,EACrB,KAAK,EACL,UAAU,EACV,KAAK,EACL,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,SAAiB,EACjB,UAAiB,EACjB,YAAoB,EACpB,KAAK,EACL,cAAc,EACd,SAAiB,EACjB,QAAe,EACf,SAAS,GACV,EAAE,WAAW,+BA+Gb"}