@lavalogic/scoria 0.37.4 → 0.37.5

package/dist/Components/Table/ColumnFactory.svelte.js

@@ -125,6 +125,7 @@ export function createColumnFactory() {
                 id: opts.id,
                 ...commonProps(opts),
                 accessorFn: opts.accessor,
+                getDisplayValue: opts.getDisplayValue,
                 filterValueType: FilterValueType.String,
             });
             return makeSpec('text', def, {
@@ -137,6 +138,7 @@ export function createColumnFactory() {
                 id: opts.id,
                 ...commonProps(opts),
                 accessorFn: opts.accessor,
+                getDisplayValue: opts.getDisplayValue,
                 min: opts.min ?? Number.MIN_SAFE_INTEGER,
                 max: opts.max ?? Number.MAX_SAFE_INTEGER,
                 filterValueType: FilterValueType.Number,
@@ -151,6 +153,7 @@ export function createColumnFactory() {
                 id: opts.id,
                 ...commonProps(opts),
                 accessorFn: opts.accessor,
+                getDisplayValue: opts.getDisplayValue,
                 filterValueType: FilterValueType.Bool,
             });
             return makeSpec('checkbox', def, {
@@ -163,6 +166,7 @@ export function createColumnFactory() {
                 id: opts.id,
                 ...commonProps(opts),
                 accessorFn: opts.accessor,
+                getDisplayValue: opts.getDisplayValue,
                 showTime: opts.withTime ?? false,
                 filterValueType: FilterValueType.Date,
             });
@@ -197,8 +201,12 @@ export function createColumnFactory() {
                 id: opts.id,
                 ...commonProps(opts),
                 accessorFn: opts.accessor,
-                query: (queryString) => opts
-                    .query(queryString)
+                // Forward the row to the consumer's query callback so it
+                // may scope results by row-level context (e.g. a `pod`
+                // query filtered by `row.warehouse_id`). Index dropped on
+                // the public surface but available internally.
+                query: (queryString, item) => opts
+                    .query(queryString, item)
                     .then((res) => res),
                 getDisplayValue: opts.getDisplayValue ?? ((row) => String(row[opts.id] ?? '')),
                 filterValueType: FilterValueType.Select,
@@ -211,6 +219,9 @@ export function createColumnFactory() {
         // ─── Display kinds ──────────────────────────────────────────
         display(opts) {
             const id = mintSyntheticId('display', opts.idHint);
+            const normalisedOptions = opts.getOptions
+                ? normaliseOptionsLoader(opts.getOptions)
+                : undefined;
             const def = new DisplayDef({
                 id,
                 ...commonProps(opts),
@@ -221,6 +232,8 @@ export function createColumnFactory() {
                 // column kind). Consumers opt in by passing the type they
                 // want the filter input rendered as.
                 filterValueType: opts.filterValueType,
+                getSortingFn: opts.getSortingFn,
+                getOptions: normalisedOptions,
             });
             return makeSpec('display', def);
         },
@@ -285,13 +298,20 @@ export function createColumnFactory() {
             return makeSpec('rowSelection', def);
         },
         actions(opts) {
-            const wrapped = opts.actions.map((action) => ({
-                getLabel: () => action.label,
-                callback: (row) => {
-                    void action.callback(row);
-                },
-                colourSet: action.colourSet,
-            }));
+            const wrapped = opts.actions.map((action) => {
+                // `label` may be a literal string or a `(row) => string |
+                // Promise<string>` function. The internal Def expects a
+                // `getLabel(item, index)` so wrap accordingly.
+                const labelOption = action.label;
+                const getLabel = typeof labelOption === 'function' ? (item) => labelOption(item) : () => labelOption;
+                return {
+                    getLabel,
+                    callback: (row) => {
+                        void action.callback(row);
+                    },
+                    colourSet: action.colourSet,
+                };
+            });
             const isEnabledFn = opts.isEnabled;
             const def = new ActionsDef({
                 actions: wrapped,
@@ -316,9 +336,14 @@ export function createColumnFactory() {
                 accessorFn: opts.childRows,
                 headerIcon: opts.headerIcon ?? 'chevron-down',
                 innerTableName: scoriaStorageKey(opts.name),
-                getInnerColumnDefs: () => {
+                getInnerColumnDefs: (row, index) => {
+                    // `childColumns` receives the outer row + index so the
+                    // inner column set may branch per row (pick-wave-subtype
+                    // drill-downs, for example). Outer-row args are optional
+                    // at the consumer site, so closures that ignore them
+                    // continue working unchanged.
                     const innerFactory = createColumnFactory();
-                    const innerSpecs = opts.childColumns(innerFactory);
+                    const innerSpecs = opts.childColumns(innerFactory, row, index);
                     const innerDefs = innerSpecs.map((spec) => unwrapColumnSpec(spec).def);
                     return { defs: innerDefs };
                 },

package/dist/Components/Table/Types/Public/ColumnOptions.d.ts

@@ -40,6 +40,14 @@ export interface TextColumnOptions<TRow extends object, K extends StringKeyOf<TR
     id: K;
     /** Reads the cell value from the row. Defaults to `row[id]`. */
     accessor?: (row: TRow, index: number) => TRow[K] | Promise<TRow[K]>;
+    /** Renders a different value in the cell while the underlying field
+     *  (and therefore the typed filter / sort / edit input) remains
+     *  `row[id]`. Useful for foreign-key columns where the cell shows a
+     *  resolved name but the column's identity stays the typed field
+     *  (e.g. `id: 'userName'` but the cell wants to render
+     *  "{firstName} {lastName}" instead). Returns `null` to fall back to
+     *  the accessor / default. */
+    getDisplayValue?: (row: TRow, index: number) => string | null | Promise<string | null>;
     /** Placeholder shown in the edit input when the cell is empty. */
     placeholder?: string;
     /** Maximum input length. */
@@ -61,6 +69,11 @@ export interface TextColumnOptions<TRow extends object, K extends StringKeyOf<TR
 export interface NumberColumnOptions<TRow extends object, K extends NumberKeyOf<TRow>> extends BaseColumnOptions {
     id: K;
     accessor?: (row: TRow, index: number) => TRow[K] | Promise<TRow[K]>;
+    /** See `TextColumnOptions.getDisplayValue`. Common use: render
+     *  placeholder text like "Already Held" / "Already Released" in
+     *  non-editable cells while the underlying numeric field still drives
+     *  the typed filter UI. */
+    getDisplayValue?: (row: TRow, index: number) => string | null | Promise<string | null>;
     /** Lower bound. The edit input enforces; values outside resolve as invalid. */
     min?: number;
     /** Upper bound. */
@@ -78,6 +91,8 @@ export interface NumberColumnOptions<TRow extends object, K extends NumberKeyOf<
 export interface CheckboxColumnOptions<TRow extends object, K extends BooleanKeyOf<TRow>> extends BaseColumnOptions {
     id: K;
     accessor?: (row: TRow, index: number) => TRow[K] | Promise<TRow[K]>;
+    /** See `TextColumnOptions.getDisplayValue`. */
+    getDisplayValue?: (row: TRow, index: number) => string | null | Promise<string | null>;
     isEditable?: (row: TRow, index: number) => boolean | Promise<boolean>;
     onEdit?: (row: TRow, value: TRow[K], coords: CellCoordinates) => void | Promise<void>;
     reactiveDependencies?: (row: TRow) => ReadonlyArray<unknown>;
@@ -86,6 +101,8 @@ export interface CheckboxColumnOptions<TRow extends object, K extends BooleanKey
 export interface DateColumnOptions<TRow extends object, K extends DateKeyOf<TRow>> extends BaseColumnOptions {
     id: K;
     accessor?: (row: TRow, index: number) => TRow[K] | Promise<TRow[K]>;
+    /** See `TextColumnOptions.getDisplayValue`. */
+    getDisplayValue?: (row: TRow, index: number) => string | null | Promise<string | null>;
     /** Whether the time component is editable. Defaults to false (date-only). */
     withTime?: boolean;
     isValid?: ValidationFn<TRow>;
@@ -113,9 +130,12 @@ export interface SelectColumnOptions<TRow extends object, K extends keyof TRow &
 /** Options for `col.query({ id, header, query, ... })`. */
 export interface QueryColumnOptions<TRow extends object, K extends keyof TRow & string, TValue = TRow[K]> extends BaseColumnOptions {
     id: K;
-    /** Async query loader; called with the current user input and expected to
-     *  return matching options. */
-    query: (input: string) => Promise<ReadonlyArray<SelectOption<TValue>>>;
+    /** Async query loader; receives the current user input and the row
+     *  being edited so the result set may depend on row-level context
+     *  (e.g. a `pod` query scoped by the row's `warehouse_id`). The `row`
+     *  argument is optional at the consumer site - `(input) => ...`
+     *  callbacks continue working unchanged. */
+    query: (input: string, row: TRow) => Promise<ReadonlyArray<SelectOption<TValue>>>;
     accessor?: (row: TRow, index: number) => TValue | Promise<TValue>;
     getDisplayValue?: (row: TRow, index: number) => string | null | Promise<string | null>;
     isValid?: ValidationFn<TRow>;
@@ -148,6 +168,22 @@ export interface DisplayColumnOptions<TRow extends object, TValue = unknown> ext
      * id matching the server field name).
      */
     filterValueType?: FilterValueType;
+    /**
+     * Per-column sort comparator. Returns a `(a, b) => 1 | -1 | 0` for the
+     * given direction. Useful when the displayed `value` derives from a
+     * different field than the server would sort on, or when the value
+     * needs a non-default ordering (e.g. status enum ranked by workflow
+     * stage rather than alphabetically). Defaults to a generic
+     * `value`-derived comparator.
+     */
+    getSortingFn?: (desc: boolean) => (a: TRow, b: TRow) => 1 | -1 | 0;
+    /**
+     * Option list for `filterValueType: 'Select'`. Drives the filter row's
+     * dropdown contents. Returning a `Promise` lets consumers fetch
+     * options lazily on first read. Has no effect for non-Select filter
+     * types.
+     */
+    getOptions?: () => ReadonlyArray<SelectOption<TValue>> | Promise<ReadonlyArray<SelectOption<TValue>>>;
 }
 /** Options for `col.bubble({ header, value, colour, ... })`. Renders one or
  *  more coloured pill bubbles per row. */
@@ -216,7 +252,14 @@ export interface ActionsColumnOptions<TRow extends object> extends Omit<BaseColu
 }
 /** Single row-action entry. */
 export interface RowAction<TRow extends object> {
-    label: string;
+    /**
+     * Button label. May be a literal string, or a function that derives the
+     * label from the row (sync or async). Use the function form when the
+     * same action button should render different text per row (e.g. a
+     * combined "View / Edit" button whose label flips based on the row's
+     * editable state).
+     */
+    label: string | ((row: TRow) => string | Promise<string>);
     icon?: string;
     colourSet?: ColourSet;
     /** Invoked when the action is clicked. Receives the row. */
@@ -278,9 +321,19 @@ export interface ExpandColumnOptions<TRow extends object, TInner extends object,
      *  shape on `CreateTableOptions` so callers can use the same
      *  shorthand at every nesting level. */
     childRowId: (keyof TInner & string) | ((inner: TInner) => TInnerId | Promise<TInnerId>);
-    /** Inner column declarations. Builder closure receives a typed
-     *  `ColumnFactory<TInner>`. */
-    childColumns: (col: ColumnFactory<TInner>) => ReadonlyArray<ColumnSpec<TInner>>;
+    /**
+     * Inner column declarations. Builder closure receives a typed
+     * `ColumnFactory<TInner>` plus the outer row and its index, so the inner
+     * column set may branch per-row (e.g. a pick-wave subtype that shows
+     * shipment lines for shipment-typed waves and job lines for job-typed
+     * waves). The outer row + index arguments are optional at the consumer
+     * site - existing `(col) => [...]` closures continue to compile.
+     *
+     * Called per expansion, so the closure may safely read row-specific
+     * state. Returned `ColumnSpec` arrays are NOT cached between expansions
+     * - return shape may differ per call.
+     */
+    childColumns: (col: ColumnFactory<TInner>, row: TRow, index: number) => ReadonlyArray<ColumnSpec<TInner>>;
     /**
      * Icon rendered on the per-row expand toggle button. Defaults to
      * `'chevron-down'`. Useful when the parent context needs a richer

package/dist/Components/Table/Types/Public/TableSubApis.d.ts

@@ -52,13 +52,23 @@ export interface SelectionApi<TRow extends object, TRowId extends Primitive> {
 export interface FilteringApi<TRow extends object> {
     /** Current column-filter state. Reactive. */
     readonly state: ColumnFiltersState;
-    /** Set or clear the filter for a single column. */
-    set(columnId: keyof TRow & string, value: unknown): void;
+    /**
+     * Set or clear the filter for a single column.
+     *
+     * `columnId` accepts any string so consumers may filter on synthetic
+     * display-column ids, nested-path filter ids, and `col.filterOnly`
+     * server-only ids (all of which are not `keyof TRow`). Typed callers
+     * that pass a row key keep their narrowed inference.
+     */
+    set(columnId: (keyof TRow & string) | string, value: unknown): void;
     /** Reset every column's filter to its default. */
     reset(): void;
-    /** Change the filter mode (e.g. `'contains'` vs `'starts-with'`) for a
-     *  string column or `'between'` for a number / date column. */
-    setMode(columnId: keyof TRow & string, mode: FilterMode): void;
+    /**
+     * Change the filter mode (e.g. `'contains'` vs `'starts-with'`) for a
+     * string column or `'between'` for a number / date column. Same
+     * widened `columnId` rules as `set`.
+     */
+    setMode(columnId: (keyof TRow & string) | string, mode: FilterMode): void;
     /** Whether the quick-filter input row is visible. */
     showQuickFilter: boolean;
     /** Whether the table is showing only selected rows. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lavalogic/scoria",
   "description": "Svelte components used for the FloWMS Web Frontend",
-  "version": "0.37.4",
+  "version": "0.37.5",
   "publishConfig": {
     "access": "restricted"
   },