flexdesk 0.17.0 → 0.17.1

package/src/ui/components/data_table.js

@@ -4,7 +4,7 @@
  * Unified, reusable data table component with support for:
  * - Pagination (first/prev/next/last/jump to row)
  * - Row selection (single, range with Shift, toggle with Ctrl/Cmd)
- * - Keyboard shortcuts (Ctrl+A, Ctrl+C, Shift+Ctrl+C, Esc)
+ * - Keyboard shortcuts (Ctrl+A, Ctrl+C, Shift+Ctrl+C outside cell mode, Esc)
  * - Context menu (copy as TSV/CSV)
  * - Column sorting (internal or external via callback)
  * - Column drag-to-resize, and double-click-to-auto-size on the same grip
@@ -27,6 +27,7 @@ import {
 import { isRowActivation, isRowControl } from './row_activation.js';
 import { createChipsFilter } from './table_filter_chips.js';
 import { CellGrid } from './cell_grid.js';
+import { toTSV } from './tsv.js';
 import { ColumnReorder, cellOrder, isColumnOrder, moveInOrder, naturalOrder } from './column_order.js';
 import { ColumnGroups } from './column_groups.js';
 import { Crosstab } from './crosstab.js';
@@ -415,7 +416,10 @@ const AUTOSIZE_MAX_PX = 520;
  * ── STORY-0003, every one of them off unless asked for ─────────────────────
  * @property {'rows'|'cells'} [selectionMode='rows'] - 'cells': CELL MODE (cell_grid.js, over cell_selection.js). A click selects one cell and puts the CURSOR on it, Shift+click selects the range from the anchor to it; every cell of the range is drawn `twm-dt-cell--selected` and the cursor `twm-dt-cell--cursor` (rows are not lit). On the focused table the arrows move the cursor (Shift extends), Ctrl+arrow jumps to the edge of the block of filled cells, Home/End go to the row's ends (Ctrl: the page's corners), Tab moves right and wraps to the next row (Shift+Tab back), Ctrl+A selects every cell of the page and Escape collapses the range onto the cursor. The cursor stays on the page drawn and is scrolled into view (under `virtualize` its row is drawn). `getSelection()` still answers ROWS — the original indices the range touches — and Ctrl+C copies those rows as before. A cell is `{row, col}`: `row` the position in the order shown (`getDisplayedRows()`), `col` the data column. Fixed for the table's life; `selectToggle`, `selectMode` and `keyboardNav` beside it are ignored with a console warning. See `getCellSelection`, `setCellSelection`.
  * @property {boolean|number[]|Function} [editable=false] - Cell mode only (a warning, and ignored, without it). Which cells open an EDITOR: `true` every one, an array of data column indices, or `(colIdx, row, rowIdx) => boolean`. F2, Enter, a double-click or a printable key (which the editor starts with) opens it on the cursor cell; in it Enter commits and moves down, Tab commits and moves right, Escape restores the cell and calls nothing, and the focus leaving commits. While it is open a `render()` (a `setData` included) waits, and runs when it closes; its row leaving the virtual window commits it. An editor with no `getValue` (a factory's `{el}` around an element that is not an input, select or textarea) has no value to commit: Enter and Tab do nothing, the focus leaving does nothing, and its row leaving the window CANCELS it — it calls `commit(value)` itself.
- * @property {Object} [editors] - `{[colIdx|type]: factory}`, the editor for a column (by index first, then by its type: `columnTypes`' or the detected 'num'/'text'). A factory is `({value, row, rowIdx, colIdx, column: {index, header, type}, initialText, commit(value), cancel()}) => Element | {el, getValue?, focus?, destroy?}`; an input, select or textarea returned as it is commits its `value`. Absent: a text box (cell_editor_host.js `createTextEditor`), which commits the value unchanged when left as it was.
+ * @property {Object} [editors] - `{[colIdx|type]: factory}`, the editor for a column (by index first, then by its type: `editTypes`', else `columnTypes`', else the detected 'num'/'text' — as named, then as the built-in editors name it, 'num' being 'number' and 'date' 'datetime'). A factory is `({value, row, rowIdx, colIdx, column: {index, header, type, ...editTypes' entry}, locale, utc, messages, initialText, commit(value, move?), cancel()}) => Element | {el, getValue?, parse?, multiline?, focus?, destroy?}`; an input, select or textarea returned as it is commits its `value`. Absent: the built-in editor for the column's type (cell_editors.js `CELL_EDITORS`: text, multitext, number, bool, choice, datetime), else a text box (cell_editor_host.js `createTextEditor`). Every editor commits the value unchanged when left as it was. An injected editor replaces the built-in one for its type (or column) only.
+ * @property {Array|Object} [editTypes] - STORY-0087. Each column's EDITOR type, by position (array) or by data column index (object): a name ('text', 'multitext', 'number', 'bool', 'choice', 'datetime', or any name `editors` is keyed by) or `{type, options?, allowOther?, rows?}`. Unset, a column's editor type is its `columnTypes` type, else the detected one. 'choice' offers `options` (values, or `{value, label}`) through an AutocompleteField and refuses other text unless `allowOther`; 'multitext' is a text area of `rows` lines (3). Only editing reads it: drawing, sorting and filtering are as without it.
+ * @property {string} [locale] - STORY-0087. The locale the built-in number and datetime editors read and show their text in (Intl's; unset: the runtime's): '1.234,56' is 1234.56 under 'de-DE', '1,234.56' under 'en-US'; '31/12/2026' is a date under 'en-GB'. A datetime also takes ISO 8601 in any locale.
+ * @property {Object} [editorMessages] - STORY-0087. Words for the built-in editors' refusals, over `EDITOR_MESSAGES`: `{number, datetime, bool, choice}`.
  * @property {Function} [onCellCommit] - `({rowIdx, colIdx, value, previous}) => void | {ok, error?} | Promise<…>`, once per commit (not for a value left as the cell showed it; `previous` is the value the row holds). Resolving `{ok: false, error}`, rejecting or throwing leaves the typed value in the cell drawn `twm-dt-cell--error` with the message as its `title` and `data-error`; until it settles the cell is `twm-dt-cell--pending`. Otherwise the value is written into the row the table holds for `rowIdx` when it settles (`rows[rowIdx][colIdx]`) and drawn. Committing a refused cell back to the row's value clears the mark without a call. New rows (`setData({rows})`) drop the marks.
  * @property {Function} [onCellSelectionChange] - `(getCellSelection()) => void`, after every change of the cells selected.
  * @property {Function} [headerMenu] - `(colIdx, {colIdx, header, hiddenColumns, table}) => items`, asked on a right-click on a data column's header (or its filter cell). The items (`{label, action, icon?, disabled?, danger?, title?}` or `{separator: true}`) open the table's menu; with `columnChooser` the chooser's items follow behind a separator. `[]` or `null` shows what would show without the hook: the chooser, or the page's own menu.
@@ -427,6 +431,9 @@ const AUTOSIZE_MAX_PX = 520;
  * @property {Function} [onCommit] - With `staged`: `({edits}) => void | {ok?, error?, errors?} | Promise<…>`, called once by `commit()` with every staged cell as `{rowIdx, colIdx, value, previous}` (by row, then column; `previous` is the value the row holds). Resolving `{errors: [{rowIdx, colIdx, error}]}` (non-empty) marks each of those cells `twm-dt-cell--error` with the message as its `title` and `data-error`, and every staged value stays; `{ok: false, error}`, a rejection or a throw marks every staged cell with the message. Anything else is success: the values are written into the rows the table holds, and the staged cells and the ring are cleared. While it is out no editor opens and Ctrl+Z, Ctrl+Y and `discard()` do nothing.
  * @property {Function} [onStagedChange] - With `staged`: `({count, canUndo, canRedo, committing}) => void` after every change of the staged cells.
  * @property {boolean} [fillHandle=false] - STORY-0089. With `staged` (a warning, and ignored, without it): a FILL HANDLE (fill_handle.js) on the bottom-right corner of the cell range (`.twm-dt-fill-handle`, in the corner cell). Dragging it up, down, left or right over the cells beyond the range previews them `twm-dt-cell--fill-preview` and, on release, stages their values as ONE undo entry: each column of the range (each row, filling sideways) is continued by `projectSeries` (series.js) — one cell repeats, numbers, dates and "Item 1"-style texts a constant step apart continue, anything else repeats in a cycle — and Ctrl (Cmd) held at release repeats the block instead. A target cell `editable` refuses is skipped and drawn `twm-dt-cell--fill-skipped` until the selection moves. The range then covers what was filled. Escape during the drag cancels it. See `fill`.
+ * @property {boolean} [pasteable=false] - STORY-0090. With `staged` (a warning, and ignored, without it): Ctrl+V on the focused table (the browser's `paste` event; `paste(text)` from code) pastes a tab-separated block — what Excel and Google Sheets copy, read by `fromTSV` (tsv.js) — at the CURSOR cell, filling right over the columns shown and down over the rows in the order shown (cell_paste.js). Each value is read by its column's editor's parse (the built-in editor's for its type, or an injected `editors` factory's own `parse` property), and every cell that reads is staged as ONE undo entry; the range then covers the block, the cursor where it began. Columns past the last shown one are dropped with a warning naming how many (a console warning and a 'warn' toast). A value that does not parse marks its cell `twm-dt-cell--error` (message as `title` and `data-error`, the text kept) and the rest still stages; a cell `editable` refuses is skipped and drawn `twm-dt-cell--paste-skipped` until the selection moves. Rows past the last loaded row ask `onPasteOverrun`.
+ * @property {Function} [onPasteOverrun] - With `pasteable`: `({rows}) => boolean | Promise<boolean>`, asked when a paste runs `rows` rows past the last loaded row (the last row in the order shown; for a server's page, the last row it sent). Anything but `true` stages NOTHING; `true` stages the rows that fit and hands the extra ones to `onRowsAppend`. Without it, such a paste stages nothing, with a console warning.
+ * @property {Function} [onRowsAppend] - With `pasteable`: `({rows, errors}) => void | Promise`, after `onPasteOverrun` said `true`: `rows` the extra rows as data rows (one array per row, as long as `headers`, every pasted column read by its parse, the others null) and `errors` the values that did not read (`{row, colIdx, text, error}`, `row` an index into `rows`; that cell is null). Adding them is the consumer's; the rows that fit are staged once it settles. Without it, the extra rows are dropped with a warning.
  * @property {string|Function} [stagedRefusal] - With `staged`: the reason a frozen control carries, or `(count) => string`. Absent: "Sorting, filtering and paging are held while N changes are not committed. Commit or discard them first."
  *
  * ── STORY-0066, every one of them off unless asked for. THE CONSUMER OWNS THE DATA: each edit is a call, answered with `setData` ──
@@ -450,9 +457,16 @@ const AUTOSIZE_MAX_PX = 520;
  *  it were this tall. A ResizeObserver corrects it the moment a real size exists. */
 const VIRTUAL_FALLBACK_VIEWPORT_PX = 1000;
 
-/** The copy menu's two items — the whole right-click menu of a table without
- *  `contextMenuItems`, and its tail with them (STORY-0010). */
-const COPY_MENU_HTML = `
+/** The copy menu — the whole right-click menu of a table without
+ *  `contextMenuItems`, and its tail with them (STORY-0010). Row mode has two
+ *  items, "Copy Row(s)" and "Copy as CSV"; cell mode (STORY-0085) has one,
+ *  "Copy Cells", and no CSV copy. */
+const COPY_CELLS_MENU_HTML = `
+            <div class="twm-context-menu-item" data-action="copy-tsv">
+                <span class="material-symbols-outlined">content_copy</span>
+                <span class="label">Copy Cells</span>
+            </div>`;
+const copyMenuHtml = (cells) => cells ? COPY_CELLS_MENU_HTML : `
             <div class="twm-context-menu-item" data-action="copy-tsv">
                 <span class="material-symbols-outlined">content_copy</span>
                 <span class="label">Copy Row(s)</span>
@@ -600,6 +614,9 @@ export class DataTable {
             selectionMode: 'rows',
             editable: false,
             editors: null,
+            editTypes: null,
+            locale: null,
+            editorMessages: null,
             onCellCommit: null,
             onCellSelectionChange: null,
             headerMenu: null,
@@ -624,6 +641,10 @@ export class DataTable {
             onRowDelete: null,
             // STORY-0089. Off — no fill handle — until set.
             fillHandle: false,
+            // STORY-0090. Off — Ctrl+V is not the table's — until set.
+            pasteable: false,
+            onPasteOverrun: null,
+            onRowsAppend: null,
             ...config,
         };
 
@@ -652,6 +673,9 @@ export class DataTable {
         if (this.config.fillHandle && !this._cellGrid) {
             console.warn('[DataTable] `fillHandle` needs `staged`; ignored.');
         }
+        if (this.config.pasteable && !this._cellGrid) {
+            console.warn('[DataTable] `pasteable` needs `staged`; ignored.');
+        }
         // STORY-0091. A crosstab has no group row: its spans are `headerRows`.
         if (Array.isArray(this.config.columnGroups) && this.config.columnGroups.length && this._crosstab()) {
             console.warn('[DataTable] `columnGroups` cannot be combined with `crosstab` (use crosstab.headerRows); ignored.');
@@ -1595,6 +1619,25 @@ export class DataTable {
         return this._cellGrid?.fill ? this._cellGrid.fill.fill(to, { forceCopy }) : null;
     }
 
+    /**
+     * STORY-0090. Paste tab-separated `text` at the cursor cell, as Ctrl+V
+     * does: each value read by its column's parse, staged as ONE undo entry.
+     * Resolves `{rows, cols, staged, skipped, refused, droppedColumns,
+     * appended}` — `staged` the NUMBER of cells that changed, `skipped` the
+     * cells `editable` refused (`{row, col, rowIdx}`), `refused` the values
+     * that did not parse (`{row, col, rowIdx, text, error}`),
+     * `droppedColumns` the columns past the last one, `appended` the rows
+     * handed to `onRowsAppend` — or null when nothing was pasted (no
+     * `pasteable`, empty text, no cursor, an editor open, a commit or another
+     * paste out, an overrun `onPasteOverrun` did not accept).
+     *
+     * @param {string} text
+     * @returns {Promise<object|null>}
+     */
+    paste(text) {
+        return this._cellGrid?.paste ? this._cellGrid.paste.paste(text) : Promise.resolve(null);
+    }
+
     /** Why sort, filters and pages are held — a staged edit — or null; with
      *  a reason, `what` is refused out loud. */
     _stagedRefusal(what) {
@@ -2145,10 +2188,21 @@ export class DataTable {
     }
 
     /**
-     * Copy selected rows to clipboard
+     * Copy selected rows to clipboard — in cell mode (STORY-0085) the cells
+     * selected, or the cursor cell alone, as tab-separated raw values with no
+     * header line; cell mode has no CSV copy
      * @param {'tsv'|'csv'} [format='tsv'] - Output format
      */
     async copyToClipboard(format = 'tsv') {
+        // STORY-0085. Cell mode copies the cells selected, not their rows,
+        // and only as TSV.
+        if (this._cellGrid) {
+            if (format === 'csv') {
+                console.warn('[DataTable] copyToClipboard: cell mode has no CSV copy; nothing copied');
+                return;
+            }
+            return this._copyCells();
+        }
         const indices = this.getSelection();
         if (indices.length === 0) {
             this._notify('Copy', 'No rows selected.', 'warn');
@@ -2191,6 +2245,36 @@ export class DataTable {
         this._hideContextMenu();
     }
 
+    /**
+     * STORY-0085. Cell mode's copy: the range (or the cursor cell alone), its
+     * raw values as TSV — Excel's quoting, `tsv.js` — with no header line.
+     */
+    async _copyCells() {
+        const matrix = this._cellGrid.copyMatrix();
+        if (!matrix || !matrix.length) {
+            this._notify('Copy', 'No cells selected.', 'warn');
+            this._hideContextMenu();
+            return;
+        }
+        const text = toTSV(matrix);
+        let ok = false;
+        try {
+            await navigator.clipboard.writeText(text);
+            ok = true;
+        } catch (_) {
+            ok = this._fallbackCopy(text);
+        }
+        if (ok) {
+            const n = matrix.length;
+            const m = matrix[0].length;
+            const what = n * m === 1 ? '1 cell' : `${n} × ${m} cells`;
+            this._notify('Copy', `Copied ${what}.`, 'info');
+        } else {
+            this._notify('Copy', 'Clipboard unavailable.', 'warn');
+        }
+        this._hideContextMenu();
+    }
+
     /**
      * Download all data as CSV
      * @param {string} [filename='data.csv'] - Filename for download
@@ -7047,7 +7131,9 @@ export class DataTable {
                     } else if (key === 'a' && selectable) {
                         event.preventDefault();
                         this._selectAllShown();
-                    } else if (key === 'c') {
+                    } else if (key === 'c' && !(event.shiftKey && this._cellGrid)) {
+                        // STORY-0085. Cell mode binds Ctrl+C only: it has no
+                        // CSV copy, so Ctrl+Shift+C is left to the page.
                         event.preventDefault();
                         this.copyToClipboard(event.shiftKey ? 'csv' : 'tsv');
                     }
@@ -7198,7 +7284,7 @@ export class DataTable {
         menu.style.display = 'none';
         menu.style.position = 'fixed';
         menu.style.zIndex = '10001';
-        menu.innerHTML = COPY_MENU_HTML;
+        menu.innerHTML = copyMenuHtml(!!this._cellGrid);
         document.body.appendChild(menu);
 
         menu.addEventListener('click', (event) => {
@@ -7371,7 +7457,7 @@ export class DataTable {
         this._contextMenuCtx = custom ? custom.ctx : null;
         if (!custom) {
             if (this._contextMenuCustom) {
-                menu.innerHTML = COPY_MENU_HTML;
+                menu.innerHTML = copyMenuHtml(!!this._cellGrid);
                 this._contextMenuCustom = false;
             }
             return;
@@ -7416,7 +7502,7 @@ export class DataTable {
                 sep.className = 'twm-context-menu__separator';
                 menu.appendChild(sep);
             }
-            menu.insertAdjacentHTML('beforeend', COPY_MENU_HTML);
+            menu.insertAdjacentHTML('beforeend', copyMenuHtml(!!this._cellGrid));
         }
     }
 

package/src/ui/components/staged_edits.js

@@ -103,7 +103,12 @@ export class StagedEdits {
      * Returns whether anything changed.
      */
     stage(rowIdx, colIdx, value) {
-        if (this.committing || !this._stageOne(rowIdx, colIdx, value)) return false;
+        if (this.committing) return false;
+        const refusal = this._dropRefusal(rowIdx, colIdx);
+        if (!this._stageOne(rowIdx, colIdx, value)) {
+            if (refusal) this.grid._redraw(rowIdx, colIdx);
+            return false;
+        }
         this.grid._redraw(rowIdx, colIdx);
         this._changed();
         return true;
@@ -121,7 +126,9 @@ export class StagedEdits {
         this.history.beginGroup(label);
         try {
             for (const { rowIdx, colIdx, value } of cells) {
+                const refusal = this._dropRefusal(rowIdx, colIdx);
                 if (this._stageOne(rowIdx, colIdx, value)) { changed++; rows.add(rowIdx); }
+                else if (refusal) rows.add(rowIdx);
             }
         } finally {
             this.history.endGroup();
@@ -131,6 +138,17 @@ export class StagedEdits {
         return changed;
     }
 
+    /** STORY-0087. A text that did not parse stays in its cell, marked, in
+     *  the grid's own marks; anything staged into the cell ends that refusal,
+     *  the value its row holds included. Whether there was one. */
+    _dropRefusal(rowIdx, colIdx) {
+        const k = key(rowIdx, colIdx);
+        if (!this.grid.errors.has(k)) return false;
+        this.grid.errors.delete(k);
+        this.grid.latest.delete(k);
+        return true;
+    }
+
     /** One cell's new state and its delta in the ring; whether it changed. */
     _stageOne(rowIdx, colIdx, value) {
         const k = key(rowIdx, colIdx);

package/src/ui/components/tsv.js

@@ -0,0 +1,74 @@
+/**
+ * tsv.js — STORY-0085 (writing), STORY-0090 (reading). Tab-separated text,
+ * the format Excel and Google Sheets put on the clipboard as `text/plain` and
+ * read back from it. DataTable's cell mode copies a range with `toTSV` and
+ * pastes a block read with `fromTSV`.
+ *
+ * QUOTING. Excel quotes a cell that holds a tab, a newline (LF or CR) or a
+ * double quote, and doubles every quote inside it: `say "hi"` is written
+ * `"say ""hi"""`. Any other cell is written as it is, so a plain grid stays
+ * plain text. A writer that does not quote turns a cell holding a tab into two
+ * cells, and every column after it lands one to the right when pasted.
+ *
+ * LINES. Rows are joined with `\n` and there is no newline after the last
+ * row: one cell copied is that cell's text alone.
+ *
+ * READING. Character by character, never by splitting: a quoted cell may hold
+ * tabs and newlines, and a split that cannot know it shifts every column after
+ * such a cell into the wrong place, silently. A quote opens a quoted cell only
+ * at the start of a cell; inside one a doubled quote is a quote. A CR outside
+ * a quoted cell is dropped, so CRLF lines read as LF ones. Excel ends its text
+ * with a newline: the empty line that leaves (and any further empty lines at
+ * the end) is dropped, so a paste never carries a row nobody copied.
+ */
+
+/** One cell's text: `null` and `undefined` are empty, anything else is
+ *  `String(value)`, quoted the way Excel quotes it when it has to be. */
+export function tsvCell(value) {
+    const text = value === null || value === undefined ? '' : String(value);
+    if (/[\t\n\r"]/.test(text)) return `"${text.replace(/"/g, '""')}"`;
+    return text;
+}
+
+/** A matrix (an array of rows, each an array of cells) as TSV. */
+export function toTSV(matrix) {
+    if (!Array.isArray(matrix)) return '';
+    return matrix
+        .map((row) => (Array.isArray(row) ? row : [row]).map(tsvCell).join('\t'))
+        .join('\n');
+}
+
+/**
+ * Tab-separated text as a matrix of strings, one array per line. Empty text
+ * is `[]`; a line with no tab is one cell; empty cells are kept (`'a\t\tb'`
+ * is three cells). Lines may differ in length: each is as long as it is.
+ */
+export function fromTSV(text) {
+    if (text === null || text === undefined || text === '') return [];
+    const src = String(text);
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let quoted = false;
+    for (let i = 0; i < src.length; i++) {
+        const ch = src[i];
+        if (quoted) {
+            if (ch === '"' && src[i + 1] === '"') { cell += '"'; i++; }
+            else if (ch === '"') quoted = false;
+            else cell += ch;
+        } else if (ch === '"' && cell === '') quoted = true;
+        else if (ch === '\t') { row.push(cell); cell = ''; }
+        else if (ch === '\r') { /* CRLF reads as LF */ }
+        else if (ch === '\n') { row.push(cell); rows.push(row); row = []; cell = ''; }
+        else cell += ch;
+    }
+    row.push(cell);
+    rows.push(row);
+    // Excel's closing newline leaves an empty line behind: it is no row.
+    while (rows.length > 1) {
+        const last = rows[rows.length - 1];
+        if (last.length === 1 && last[0] === '') rows.pop();
+        else break;
+    }
+    return rows;
+}

package/tiles.js

@@ -0,0 +1,27 @@
+/**
+ * @flexdesk/tiles — A draggable, resizable widget grid: the tile base class, the grid, the
+ * widget registry, layout persistence, a chart and a KPI tile (0.13.0), a list and a
+ * people tile and a board-wide scope picker (0.16.1), the figure tile every
+ * Plotly tile draws through and the config form (0.17.0).
+ *
+ * It stores layouts under keys YOU choose and resolves starting templates
+ * through a callback YOU supply. It has no opinion about what a layout is
+ * keyed by.
+ *
+ * GENERATED by scripts/gen_barrels.py. Do not hand-edit. (0.13.0: hand-edited to
+ * add chart_tiles.js — the generator is not in this repository; 0.16.1: list_tiles.js
+ * and scope_picker.js, the same way; 0.17.0: figure_tile.js and tile_config_form.js.)
+ *
+ * 10 modules.
+ */
+
+export * from './src/tiles/chart_tiles.js';
+export * from './src/tiles/config_schema.js';
+export * from './src/tiles/figure_tile.js';
+export * from './src/tiles/layout_persistence.js';
+export * from './src/tiles/list_tiles.js';
+export * from './src/tiles/scope_picker.js';
+export * from './src/tiles/tile_base.js';
+export * from './src/tiles/tile_config_form.js';
+export * from './src/tiles/tile_grid.js';
+export * from './src/tiles/tile_registry.js';

package/widgets.js

@@ -0,0 +1,69 @@
+/**
+ * @flexdesk/widgets — The widget set: DataTable, modals, managed windows, toasts, trees,
+ * context menus, menu bars, panels, section stacks, a step wizard, the help modal and the notification centre.
+ *
+ * GENERATED by scripts/gen_barrels.py. Do not hand-edit.
+ *
+ * 59 modules.
+ */
+
+export * from './src/ui/base/component_base.js';
+export * from './src/ui/base/controller_base.js';
+export * from './src/ui/base/page_base.js';
+export * from './src/ui/components/about_dialog.js';
+export * from './src/ui/components/alert_log.js';
+export * from './src/ui/components/alerts_pane.js';
+export * from './src/ui/components/action_dropdown.js';
+export * from './src/ui/components/attribute_list_editor.js';
+export * from './src/ui/components/autocomplete_field.js';
+export * from './src/ui/components/cell_editor_host.js';
+export * from './src/ui/components/cell_editors.js';
+export * from './src/ui/components/cell_selection.js';
+export * from './src/ui/components/color_field.js';
+export * from './src/ui/components/color_list_field.js';
+export * from './src/ui/components/column_fit.js';
+export * from './src/ui/components/computing_status_window.js';
+export * from './src/ui/components/confirm_dialog.js';
+export * from './src/ui/components/context_menu.js';
+export * from './src/ui/components/conversation_view.js';
+export * from './src/ui/components/data_table.js';
+export * from './src/ui/components/detail_header.js';
+export * from './src/ui/components/document_outline.js';
+export * from './src/ui/components/drag_reorder.js';
+export * from './src/ui/components/fact_table.js';
+export * from './src/ui/components/gallery_picker.js';
+export * from './src/ui/components/inline_renamer.js';
+export * from './src/ui/components/managed_window.js';
+export * from './src/ui/components/menu_bar.js';
+export * from './src/ui/components/modal.js';
+export * from './src/ui/components/notification_history.js';
+export * from './src/ui/components/progress.js';
+export * from './src/ui/components/record_list.js';
+export * from './src/ui/components/section_stack.js';
+export * from './src/ui/components/series.js';
+export * from './src/ui/components/settings_view.js';
+export * from './src/ui/components/slide_out_panel.js';
+export * from './src/ui/components/slider_field.js';
+export * from './src/ui/components/sortable_list.js';
+export * from './src/ui/components/staged_history.js';
+export * from './src/ui/components/table_state_store.js';
+export * from './src/ui/components/tabs.js';
+export * from './src/ui/components/tag_input.js';
+export * from './src/ui/components/toast.js';
+export * from './src/ui/components/toggle_field.js';
+export * from './src/ui/components/tree_view.js';
+export * from './src/ui/components/tsv.js';
+export * from './src/ui/components/window_taskbar.js';
+export * from './src/ui/components/wizard.js';
+export * from './src/ui/controllers/window_chrome_controller.js';
+export * from './src/ui/notification_center.js';
+export * from './src/ui/utils/auto_scrollbars.js';
+export * from './src/ui/utils/markdown.js';
+export * from './src/ui/utils/native_context_menu.js';
+export * from './src/ui/utils/overlay_scrollbar.js';
+export * from './src/ui/utils/raf_resize_observer.js';
+export * from './src/ui/utils/scroll_lock.js';
+export * from './src/ui/utils/strip_scroll.js';
+export * from './src/ui/utils/tooltip_service.js';
+export * from './src/help/help_modal.js';
+export * from './src/help/help_registry.js';

package/wm.js

@@ -0,0 +1,28 @@
+/**
+ * @flexdesk/wm — The tiling window manager: tiles, tabs, splits, desktops, the command
+ * palette, the taxonomy and entity registries, and createShell().
+ *
+ * GENERATED by scripts/gen_barrels.py. Do not hand-edit.
+ *
+ * 19 modules.
+ */
+
+export * from './src/tiling/bottom_panel_tabs.js';
+export * from './src/tiling/command_palette.js';
+export * from './src/tiling/content_registry.js';
+export * from './src/tiling/desktops.js';
+export * from './src/tiling/entity_sources.js';
+export * from './src/tiling/keymap.js';
+export * from './src/tiling/kind_taxonomy.js';
+export * from './src/tiling/landing_table.js';
+export * from './src/tiling/loading_overlay.js';
+export * from './src/tiling/nav_panel.js';
+export * from './src/tiling/page_factory.js';
+export * from './src/tiling/panel_keys.js';
+export * from './src/tiling/shell.js';
+export * from './src/tiling/tile_breadcrumb.js';
+export * from './src/tiling/tile_renderer.js';
+export * from './src/tiling/tile_tab_menu.js';
+export * from './src/tiling/tile_tree.js';
+export * from './src/tiling/wm.js';
+export * from './src/tiling/zoom.js';