Repository navigation
Merge every open view branch and check them as one - #114
Merged
Merged
Conversation
…ar and the bars The prototype drew its toolbar, its Back/Forward/Up and its activity bars as single-colour glyphs; the shell drew every icon in its file's colours. A <dex-icon mono> now draws the same file in the element's currentColor: an SVG <image> of it through a filter that keeps the strokes and dark shapes as ink and drops the light fills. It follows the theme and forced colours with no dark-set filter, and no second icon set ships. Not a CSS mask: a mask image is fetched in CORS mode, which a file:// page (the Electron app's) is refused, so every icon vanished there, and an alpha mask filled each white tile solid. The <image> loads as an <img> does, under img-src 'self'. <dex-toolbar>, <dex-location-bar> (its three buttons, not the segments) and <dex-app-shell> (the activity bars' and the status bar's buttons) gain a reflected mono property, off by default, so a page that does not set it draws as before.
…olbar's labels kept ShellSettings gains iconStyle (minimal, the prototype's default, or colorful) and tableStyle (grid, the table's own default, or rows). A record an earlier version kept, with the theme and the toolbar alone, reads back on the new defaults. The popover's rows are Theme (Auto now first), Toolbar, Icons and Table, and the compact toolbar's tooltip no longer says "Icons alone": its labels stay, beside smaller icons. connectShell applies them: Minimal sets mono on the toolbar, the location bar and the shell, and the table style goes to every open table and to each one it makes later (Rows is the tree table's light style), the banner table of a file that could not be read included. docs/widgets/settings-panel.md's generated half prints ShellSettings from the source; the next build writes it.
…ok disabled The cut icon is a tile drawn in light greys with a dotted cut line, and beside Copy's solid tile an enabled Cut read as a disabled one in the colourful style. The toolbar's Cut now draws scissorToolUI, the MathWorks set's scissors in the dark grey of the other enabled glyphs, in both icon styles. The table's context menu keeps the cut icon, so the menu is as it was. src/widgets/icon-assets/assets.ts and dist/ name the new icon once the next build writes them.
… glyphs The review's minors. The ink filter's comment names the two colours the icons draw between the bands, the gear's middle disc (#A6A6A6, half ink) and Delete's red tile (#FF9D9A, a faint fill), and the test pins both. mono's doc and the icon page say each mono icon runs a filter of its own, so it is for the handful of glyphs an app's chrome draws, not a long list, and that a missing file draws nothing in mono where the <img> draws a broken image. The dark-filter test also holds the host free of --dex-icon-filter. The prose added to the README, the Settings page and the Settings test is rewrapped.
… its Usage A JSON dictionary's edit paints its entry at once, writes the text, and on the text's change repaints the entry once its Usage column is filled. With a usage source that fill is awaited, so an undo pressed straight after the edit (which repaints the entry at once) landed first, and the echo's older rows then came in over it: the table showed the edited value while the text, and every save, held the undone one. A narrow repaint that waited on the Usage column is now dropped when a newer paint of the same entry, or a wide repaint, went out meanwhile. The race was there with a folder shown, and in the VS Code extension's dictionary editor, which runs the same engine with its usage graph; the shell met it on every dictionary once the open tabs fill the column.
With only files open (dropped, or picked one by one), a dictionary's or a MAT-file's table hid its Usage column, and a model's blocks named no source file: the column was answered only by a shown folder's usage graphs. The prototype answered it from its open files. The shell's workspace now takes a usage source over the open tabs (createOpenFilesUsage): the same UsageGraphs a folder session gives, over the bytes each tab holds as last read or saved, so a dictionary's entries name the blocks of the open models that read them, and a model's parameters resolve to an open dictionary by its uri (unresolved until it is open, as a folder without the dictionary answers). A tab opened, closed, saved or reloaded repaints, once the burst is over, each table whose column was answered over other tabs than are open now. A folder shown still wins: its session fills the column from then on, and a file outside it shows none, as before. An editable .slx now repaints when a usage source comes later (setUsage), as the read-only model and the data files did; its refill did nothing before.
…each is The Search view matched entry names alone, as a substring, in alphabetical order, and its rows did not say what an entry is. The prototype ranked its open files' entries by name, value and data type, a prefix before a substring before a fuzzy match, and showed the type. searchRanked does that: each field by its strongest match (a prefix, a substring, or for the name its letters in order), the strength first, then the name before the value before the type, and where an entry is (a block's path, its file's name) last, as a substring, as before; the cap applies after the ranking, so a broad query keeps its best matches. The open files' records carry their rows' Value, Data Type and Class cells (namesOfRows with `cells`); a folder's index reads names alone, so its entries rank by name. Each row ends with the entry's class, else its data type (SearchItem's `type`), as the prototype showed it. The extension's search is untouched: searchEntries keeps its rule and order, namesOfRows its records without `cells`, and a record with no cells makes the item it always did. The folder part's own search box still uses searchEntries.
…iable's value for json `add Parameter x` was refused: the window took a class only by its full name (Simulink.Parameter), in any case. It now takes the last part of the dotted name too, as the prototype did, and where two classes end in it asks which. `json` on a MAT-file's variable, or a Model Workspace's, printed only how many bytes it holds, since its raw form is the bytes it was read from (the Raw pane's dump). It now asks for the record (TableSource.raw's new `record` option), the JSON a save writes and the prototype printed, and gets it for a variable of up to HEX_LIMIT bytes; a larger one, or one core will not write, still answers its bytes. Without the option every answer is as before, and a source across a channel has no raw at all.
…illing first The guard against a stale narrow repaint compared with the entry's last paint sent, so of two repaints waiting on the Usage column the older one, landing first, won and dropped the newer. With the graph cold (fillNow cannot fill, as the extension's is after any editor opens or closes), an edit's own repaint and the take-back of its refused write both wait: the edit's landed first, the take-back was dropped, and the table showed the refused value while the text held the old one. Each narrow repaint now takes its entry's turn as it begins, and a paint sent at once takes one too; a repaint lands only if it still holds its entry's latest turn and no wide repaint began since. The undo race of the last fix still holds, and the refused edit is a test of its own.
With only a model open, a block parameter its dictionary would answer was unresolved over the open files, so its Usage cell named no file and linked nothing, where the file alone had linked the dictionary by name. A page of open files is not a folder that lacks the dictionary: it is most likely beside the model, unopened. Over the open files only, a parameter left unresolved (not the workspace's, not a mask's) in a model that links a dictionary now names that dictionary as the model records it, `Value=Uo (params.sldd)`, linked `Uo@params.sldd`, which opens it beside the model, as the prototype linked it. Once it is open the parameter resolves to it by its uri, and a parameter the workspace shadows still names the workspace. The folder's and the extension's graphs are untouched: the name is the open files' cell, not the graph's. The link tests read DictOnly's link again.
…efore its fill RawOptions (TableSource.raw's `record`) and NamesOfRowsOptions (namesOfRows' `cells`) are named in the model entry's signatures, so the entry exports them as types. A document asked to repaint over the open files counts as filled over the files of the ask, and a test now holds that: a second burst that puts the files back as they were asks it again. connectShell says what a Close Folder would hand back, and the Search pane's head comment is wrapped as the rest are.
…y it A table offered Undo and Redo wherever its document could be edited, so a file just opened had both enabled with nothing to take back. An editable source may now say where its stack stands: EditableTableSource.history (EditHistory: canUndo, canRedo, and onChange when either moves). The page's own stacks are histories (EditStack, and the JSON dictionary's text store), the engines hand on the one they are given (a new `history` option), and every document a workspace edits gives its table its stack's. A listener's throw goes to the workspace's notify, never back into the edit. Optional throughout: a source across a channel, as the VS Code extension's, and an engine given no history (the extension's host gives none) have none, and a table keeps offering both as before.
…enu key Rows take no focus (the grid does, and the arrows move a cursor over it), so the browser's own menu event for those keys reached the grid as a right-click on no row, which a dictionary's table answers with no menu, and Chromium on macOS sends none at all: a keyboard user had no row menu. With the new `keyboardMenu` (attribute `keyboard-menu`), both keys on the grid send dex-table-context-menu for the keyboard's row (the row the arrows moved to, else the selection's last), under it and inside the grid, or for the space under the rows when there is none. The keys are spent, the ContextMenu key's keyup too (Windows sends the browser's event then), so no second menu event follows. A cell editor's keys and a header filter button's stay theirs. Off by default, so a table that does not ask (the VS Code extension's) keeps both keys the browser's, as they were. A right-click sends what it sent.
The toolbar's Save always drew the grey floppy. As in the prototype it is now the blue one (unsaved.svg, added from the MathWorks icon set the others come from) while the active document holds edits its file does not, and the grey one again once they are saved. The icon assets' generated list takes the new file at the next build.
…gesture it ran The editing menu's Undo and Redo, the handle's can() and run() for them (an app's toolbar and palette) and handle.undo()/redo() follow the source's `history` where it has one: each is offered only where there is a step, and a greyed one says "Nothing to undo" as Paste says its clipboard is empty. A source without one keeps both offered wherever the document may be edited, as the VS Code extension's does. The Undo chords are still the table's, and send nothing where there is nothing to undo. The handle's new `ran` says each editing menu item's gesture the table handed its source, from the menu, a chord, run() or undo()/redo(): its actionId, the rows it carried and how many it acted on, as the item's label counts them (entries copied or cut, items deleted, the clipboard's entries pasted). It is told a task later, and not where the source refused it, said an error or threw meanwhile, which a source in the page does before then: an app's "Copied to clipboard" is said only of what was done. The toolbar test whose Undo commits an open cell editor first makes an edit before it, since a file just opened now has nothing to undo.
…ables the keyboard menu As the prototype said them, the shell toasts (and logs) "Copied to clipboard", "Cut to clipboard", "Pasted" and "Entry deleted" or "N entries deleted" after each of those gestures, from the toolbar, a chord, the palette or the menu alike: from the table handle's `ran`, so a gesture the document refused or a press with nothing selected says nothing. The toolbar is drawn again whenever the active document's undo history moves, so Undo and Redo follow it even where no repaint does (a reload of the text a JSON dictionary already held). The shell's tables open their row menu on Shift+F10 and the ContextMenu key (keyboardMenu). The README says where a document's undo stack stands, what `ran` tells, and the new keys.
…s it closes A menu opened by Shift+F10 left the keyboard on the table's grid. The first ArrowDown entered the menu and moved the selection too, so Enter then copied (or deleted) the next row, and when the menu closed the focus was on the page's body. The context menu's show() takes `focusFirst` now: the keyboard is on the first item at once, and goes back to the element that had it, inside a shadow root too, on Escape or a choice (before the choice is sent, so a dialog it opens keeps the focus). A click outside leaves the focus where it put it. The table marks a menu its keys opened (`keyboard: true` in dex-table-context-menu's detail), and connectTable shows that one with `focusFirst`. A right-click's menu, and every caller that does not ask, is as it was, so the VS Code extension's tables are unchanged. The menu keys also named a row the table no longer showed: the arrows' row outlives a delete. They take it only while the table shows it, else the selection's last shown row, else none. And the grid names the keys for assistive tech (aria-keyshortcuts) where keyboardMenu is on.
…t follows the history What the shell says of Copy, Cut, Paste and Delete (ranNote) moves out of documents.ts into connect/editingNotes.ts, with tests of its own. The shell test now holds the toolbar to the document's undo history where no table change follows it (a reload of the text a JSON dictionary already held drops its Redo), and to a keyboard-opened menu taking the keyboard and giving it back to the grid. The editing wire's comment says that a refusal arriving late can silence an unrelated gesture handed in the same task.
… the keyboard back however it closes Chromium on Windows opens its own menu on the ContextMenu key's keyup unless the keyup is spent. Now that a menu a key opened takes the keyboard during that keydown, the keyup lands in the menu, where nothing spent it, so Chrome and Edge on Windows would open their menu over ours. While such a menu is open it spends that key's keyup (heard from show() on, as the keyup can come before the menu's first frame) and any contextmenu event on it. A menu a right-click opened leaves both to the browser, as before. And a menu opened with focusFirst gives the keyboard back to where it was whenever it closes holding it: Escape, a scroll, a right-click outside, or close(), as well as a choice. A click outside still moves the focus where it goes.
…ows that edit A table's inspector showed one row's properties, read-only, and nothing for no row or a section heading. A document's table now answers more where it is asked (inspect's new options): with `pages`, the file's own page while no row is selected (its name, kind, core's facts of it, where it is, whether it holds edits, and the open files it references and is referenced by, as links), a section heading's (its entries counted by type), and "N selected" for several rows; with `editable`, a row's properties editable where core offers an editor of them, keyed by the property an edit names, a choice listing its options and a description its lines. Every document answers through one rule (inspectTree), as the Raw pane's do through rawOfRow. connectTable asks for them with two new options, `inspectorPages` (which also adds a row's Usage links as a group) and `inspectorEditing`; the handle writes an inspector's change back as a cell edit is, a refusal in the table's dialog and the page sent again, and refreshInspector() asks again for what the table does not hear (the file's unsaved state). connectInspector hands a change of an editable row to a feed that takes edits. The inspector draws a choice as a list and a text of lines as a field of several lines, and names the row's key in dex-property-changed. Every default is as before: asked without options a source answers exactly as it did, and buildPropertyGroups, InspectorSelection and InspectorPage, which the VS Code extension's inspector is built from, are unchanged without them. A section's page is drawn here, since core's section nodes have no property layout; a file's root name is the uri core registers it under, so the page names the file itself.
…t Root The shell's tables ask for the inspector's pages and editable rows: the Properties view shows the active file's page while no row is selected (so a tab shown or a selection cleared no longer leaves the empty text), a section heading's and several rows' pages, a row's Usage links, and edits a row as a cell edit is. A link on it goes where a table's link goes, through the folder shown. The file's page says whether it holds edits again on every change of the tab's unsaved state, a save among them. At Root, a box clicked in the relationship graph (or an item, for its box's file) shows that file's page, drawn from what the graph knows of it, open or not, and the location bar a dimmed "Root › file" after Root, which opens the file when pressed; a click on the graph's background clears both. The graph pane says when its selection changes, and opens the selected file or a file its page links as a double-click on its box would. The location bar's segments take `preview`, drawn dimmed (still 4.5:1) after the current place.
…still there A field's text was its row's value, put back (live) whenever the page was pushed again. A change of one field is answered by the page pushed again up to three times (its repaint, the resend after the edit settles, the shell's refresh for the unsaved state), so what the user was typing meanwhile in the next field was wiped. A field typed in now keeps its text until it is changed or left; every other field follows its row, a refused one put back as before. A Save chord given with the focus still in a field saved without what was typed there, since the field commits only on its change. The inspector's new commit() sends the focused field's change as leaving it would (once: the change its blur fires after is the one already sent), connectInspector's handle has it, and the shell calls it before the table's commitEdit() on a save, a tab's or the window's close, and the Gallery's add. Each field is named for a screen reader by its property (aria-label), and a choice with no value, for which core names no default, shows empty and offers only the choices rather than a blank one.
…e dimmed segment A file's page listed core's root facts as they came, so a .mdl showed a blank Release. A fact with no value is left out now. The location bar's segments take a `description`, what a screen reader hears past the label, and the shell gives the dimmed file at Root "selected in the graph", so it is not heard as a place the user is in. Tests pin three more cases: an inspector edit undone as a cell edit is, one step, the page following; an edit landing on its row while the selection has moved on, the next row's page shown; and a Value shown as a summary staying read-only though core offers an editor of its whole text.
…d a dimmed segment The hand-written halves of three pages. The property inspector's says what a table connected with inspectorPages shows (the file's, a section's and several rows' pages, a row's Usage links), how a row edits (its key, a list for options, several lines for multiline, the change handed to a feed's edit), the commit() an app's Save calls, and inspect's options. The tree table's says what inspectorPages and inspectorEditing send, handle.edit(), and when to call handle.refreshInspector(). The location bar's says what `preview` and `description` draw. The generated half of the inspector's page waits for the build, which writes the event detail's new key into it.
…fore the page moves on What was typed in a field was kept by the field's place in the page, not its row's. A selection moved with no blur (a native menu's Back, a command, a host's select) left the text in the next row's field, where a Save's commit() or the later blur wrote it to that row; and a field drawn anew at the same place (the inspector following another feed and back) was left blank. connectInspector now commits the focused field before it shows another row's page or follows another feed, while it still names the row and the feed the text was typed in, so the edit goes to that row. And the widget keeps typed text only in the field the focus is in: any other, a new one among them, shows its row's value. The memo that keeps a commit from being sent twice names the row it was sent for, so a change of the next row's field is its own.
The graph listed a model's blocks only where a usage of them was drawn, so a model opened without its data had no items, no + on its box, and nothing to show of what its blocks read. The prototype listed every block a parameter of which names something. Each such block is now an item, built from core's own block key, label and path as its usage index builds a usage's, so the item is the same one, id included, whether or not the data it reads is open.
…the pointer is on
As the prototype's graph did. A box newly in `expanded` (its + pressed, the
app answering) is what is lit: the view moves onto it and the files it
reaches along data links, dictionary references and usages, and every other
box and edge is dimmed, until the box is closed, Escape is pressed or the
background clicked. A selection lights over it. The boxes a graph comes with
are not taken as opened. A double-click on the background asks to close every
open box and fits the graph.
The pointer on an item lights what it is joined to, as a selection of it
would, and gives back what was lit when it leaves; on an edge under the
boxes, the other edges fade. A data link is drawn in the border colour of
the file it links, a dictionary's green or a MAT-file's sand, with no token
of its own, and a usage is labelled as the block's property (".Gain").
zoomToReach(id) moves the view onto a box or an item and what a selection of
it lights, keeping the thing itself in view where they do not fit. The
shell's Show in Graph uses it in place of reveal(), and opens the file's own
box onto its items as the prototype opened a model; a file a reference row
names is shown as it is.
…g it focused A click on a box's + leaves the toggle focused, and the graph left every key on a button to the button, so Escape after opening a box did nothing until the canvas was clicked. A button has no use for Escape: it now clears the selection and the dimming from there too.
… need The complex_dataflow set (eight models one tree five leaves wide, five dictionaries one tree three wide, two MAT-files) drew 2170 pixels wide: every file had a slot as wide as its column's widest box, and the gap between the columns was the prototype's 300. In the app shell at 1440 by 900 the graph gets about 900 by 610, so at the 0.6 fit floor a label was 6.6 pixels and the data files were off the screen, and a model opened was zoomed to at 0.65. The look stays the prototype's two columns of top-down trees. A file now takes the width it needs and its subtree its children's side by side, the file centred over them within its own span; trees still wrap at three (models) and two (data files) of the column's widest boxes. The gap is as wide as the data links' lanes need, 8 pixels apart over 60% of it, between 120 and 300. Both are decided by the graph, so opening a box moves nothing sideways. The same files draw 1890 wide. The fit floor is 0.7, where a label is near 8 pixels, and the fit no longer takes a tenth off the scale (the layout has its margin). PowerTrain opened is now zoomed to with its three data files at 0.77, both columns on the screen; Show in Graph zooms the same way. layout.ts and the widget's doc say what fits at 1440 by 900, and why.
…aying the default `layout` on <dex-relationship-graph> (attribute and property) chooses how the columns are drawn: 'tree', the default, the prototype's top-down trees; or 'indented', each column a file tree, one box a row, what a file references in the rows under it a step to the right with a line down the referrer's left side, and a reference to a file drawn under another referrer round the outside of its column. A column too long for a 900 by 600 canvas is dealt into columns side by side, whole trees each, when that draws it at least a fifth larger, decided with every box closed. layoutGraph takes the style; the gap between the columns is sized from the lanes in both. For the complex_dataflow set in the shell at 1440 by 900 the trees draw 1890 by 390, fitted at 0.7 with the data files off the screen, PowerTrain opened at 0.77; indented they draw 740 by 540, fitted at 1.0 with both columns on the screen, PowerTrain opened at 0.87. A change of layout fits the graph afresh and keeps what is open and selected. The graph pane's setLayout(layout) sets it, for a setting to choose; the shell passes nothing yet. The arrows move only to a box wholly past the selected one's side, so in an indented column of unlike widths Left and Right leave the column. Every layout test's invariants now run over both layouts.
… with each other The Folder view is where files are before any is open, so it compares them too. A data file's row menu gains Compare With… after Open to the Side: the file opens in a tab kept, and the shell asks which file to compare it with. With two data files' rows taken into the selection, the menu of either begins with Compare Selected, which opens both, kept, and compares the first with the second in the tree's order. A row of a file the app does not open, or a project's, offers neither. For that the folder tree takes several rows at once, opt in: with `multiSelect`, Cmd+click on macOS or Ctrl+click elsewhere takes a row into the selection or out of it without opening it, `selectedKeys` and `selectedItems` say which are selected, and dex-hierarchy-selection-changed says when that changes. A plain click and Enter select one row and send what they always sent. A screen reader hears the tree as multi-selectable, each row's selection with it; the keyboard reaches the compare through the row menu. A tree without multiSelect is as it was.
…inks) into the compare's shell work share/links brings share V5: Open from URL…, Copy Link, and a tab's menu (connect/tabMenu.ts), which the compare's Compare With… and its Next and Previous Change are added to, one module for both; and the web addresses' code without the forge's name, which clears check:leak. # Conflicts: # custom-elements.json # dist/browser/urls.d.ts # dist/browser/urls.js # dist/widgets/app-shell/connect/types.d.ts # dist/widgets/app-shell/index.d.ts # src/widgets/app-shell/connect/carryOut.ts # src/widgets/app-shell/connect/connectShell.ts # src/widgets/app-shell/connect/documents.ts # src/widgets/app-shell/connect/fileMenu.ts # src/widgets/app-shell/connect/paletteItems.ts # src/widgets/app-shell/connect/requests.ts # src/widgets/app-shell/connect/tabMenu.ts # test/checkApi.test.ts # test/typedApi.test.ts
…links merged The compare tab in the shell (Compare With…, F7, the tab, Explorer and line menus, Copy to Left and Right, the Folder view's Compare Selected) and share's Open from URL, Copy Link and tab menu, merged above: dist/, the widgets' manifest and the generated half of their docs pages.
…ws from the keyboard too Copy Link listed every tab as an open file, so a compare tab went to the host as a file of no path named "a.sldd ↔ b.sldd", and its link was at it. The open files are the files' tabs now: from a compare tab's menu, Copy Link links both compared files with the rest, at none of them, as Root's does. A Folder tree that says it selects several rows (aria-multiselectable) now lets the keyboard do it: Cmd+Space on macOS, Ctrl+Space elsewhere, takes the focused row into the selection or out of it, as the tree pattern's Control+Space does. Smaller: a tab's first paint is waited for by one helper, open-at's, which also settles when the table's source could not open its file, so a compare of such a file says it could not be read. A copy whose source will not lend its entries, or whose drop throws, is said and the next section tried, the drag still ended. The compare tests also hold that a refused copy leaves the target clean with nothing to undo, and that an added numeric array is one step of F7.
Copy Link from a compare tab, the Folder tree's Cmd/Ctrl+Space and the one wait for a tab's first paint, above: dist/, the widgets' manifest and the generated half of their docs pages.
…light and dark The app page opens object_props_text.sldd before object_props_binary.sldd, so the two dictionaries that differ in the zip one's fleetObject Notes are open side by side. A new gallery test right-clicks the text dictionary's tab, picks Compare With… and the zip dictionary in the palette, and checks the compare tab, the header's "1 changed" and the two captions. F7 then selects the one change in both tables. The compare is kept as a light and a dark screenshot, for a person to look at. The app test counts five tabs now. Screenshots go through one helper that takes none in WebKit. Playwright's WebKit screenshot first adds a style element to the page to line up its animations. The page's policy refuses it, and the refusal is a console error that fails the test. The Folder view's screenshot, which failed in WebKit for that reason, uses the helper too.
…ight from its observer A gap row stands for a row only the other file has, so it holds nothing to open. Its twisty, its aria-expanded and Space on it now go, through the table's one rule for whether a row can open. Its indent and its hatching stay, so the lines still meet the other side's. The gaps under it still show and hide as the other side's row is opened and closed, since the compare view hands both tables the same open lines. A table given its rows before its first render draws its grid in that render. It measured the grid's height in firstUpdated, which set state inside the update: a second render at once, and Lit's change-in-update warning in an app's dev console. Each of a compare's two tables did this. The resize observer, which already kept the height up to date, now takes the first one as well. Its first callback comes before the first paint, so no frame is drawn with the default height's window. The gallery's dev-mode warning test now opens the app page's compare too, and failed on the warning before the change. The compare test checks the gaps' missing twisty in a browser.
The tree table's build, its declarations, custom-elements.json and the generated part of its widget docs, for the gap rows that open nothing and the first height taken from the resize observer.
…focused table's cell, and refuse Compare With… on a compare tab at once A compare's heading counted the lines under it, the other file's gaps among them. So rt_bin.sldd's side read "Design Data (3)" for params.sldd's three entries, though rt_bin.sldd has none there. Each side's heading row now carries its own file's count, the entries of that section the side has (`_entryCount`, a new optional field of TreeTableRow). The table draws that count in place of the rows under the heading. That reads as the file's own table reads it: an empty section is "(0)", and "Show only differences" narrows the lines, not the count. A heading only the other file has stays a gap, with no count. A table given no `_entryCount` counts the rows under a section as before. Both of a compare's tables select the same line, and both drew the focused cell's ring on it, though only one has the keyboard. With diffMarks, a table now rings the cell only while the keyboard is in its grid. The selection stays drawn on both, and a table with no marks rings its cell as it always has. Compare With… on a compare tab now says at once that a comparison can't be compared with another file. The shell's own menus never offer it there, but a host's native menu has the item on every tab, and the shell used to ask for a file and refuse only after the pick.
The layout's heading counts, the row field that carries them, the tree table that draws them and rings only the focused table's cell, the shell's at-once answer to Compare With… on a compare tab, custom-elements.json, and the generated part of the tree table's docs.
A host's native menu has Compare With… on every tab. On a project's tab the shell asked for a file and refused only after the pick, since a project has no table to compare. It now says at once that the project has no table and that only data files are compared, as it does on a compare tab. The shell's own menus still offer no Compare With… there. The focus ring the reviewer asked for went in with the section counts (c57975b): with diffMarks, a table rings its focused cell only while it has the keyboard.
The shell's at-once answer to Compare With… on a project's tab.
…pace does In a dex-hierarchy with multiSelect, plain Space on the focused row now takes it into the selection or out of it, as the multi-select tree pattern's Space does. Mod+Space still does the same. On macOS, Cmd+Space is Spotlight's and Ctrl+Space switches the input source, so Mod+Space rarely reached the page there; Space alone does. Shift+Space, Alt+Space and, on macOS, Ctrl+Space are left alone, and a tree without multiSelect leaves Space alone as before. The JSDoc and the widget docs say so. The tree table's comment on read-only ink over a wash gave the dark set's muted ink as 4.32:1 on the plain surface. That was #888; the token is #8c8c8c now, which gives 4.55:1 on the lightest surface (#252526) and 3.4 to 3.7:1 on a wash, and the comment says so.
On a loaded machine (load averages of 14 to 58) a few tests ran past the 5 s default and the 10 s hook default, then passed alone. Each now does its work once, or is given the time that work takes, with a comment saying what the work is. The global timeouts are unchanged. - checkApiSurface: each case builds a TypeScript program for its small package, and most of what that program parsed was TypeScript's own lib files. api-surface.mjs now parses those once a process; the surface it reads is the same (checked on this package's own build: 1871 items, the same). The cases' folders are taken away with each case, not all in one afterAll hook, which is the hook that timed out. The cases get 20 s each. - iconSet: core's dist was scanned twice, once for each case that reads its ids. It is now scanned once, in a hook given 20 s, and the scan helper keeps its answer. The SVG check reads every icon with one assertion over all of them, not one per file. The widget-source case gets 20 s. - dexIcon: the two plain-Node cases each started Node, happy-dom and the built module. One process now draws both icons, once, in a hook given 45 s. execFileSync kills it at 30 s, so a process that hangs fails the hook rather than holding the worker. - usageScopeEquality: the exhaustive case planned the whole corpus twice, for the unscoped graph and for the probes. It plans it once now, and gets 20 s; each file's scoped graph is still built from nothing. - widgetDocs: the generator check runs gen-widget-docs in its own process. It gets 45 s and the process is killed at 30 s. The case that parses every source file gets 20 s. Both failed under two suites at once. - folder.test's Search view case: a folder change re-lists the folder and rebuilds the index, past the harness's 3 s waits under load. Its waits get 15 s and the case 45 s. folderGraphSources needed no change here: on this branch it waits for the tree's hierarchy build rather than a quiet spell, and it took 62 to 138 ms alone and under load.
The hierarchy's Space toggle in a multi-select tree, its JSDoc in custom-elements.json and the generated part of its widget docs, and the tree table's corrected comment on the dark set's muted ink.
…ed, word Space plainly, and drop dist files with no source api-surface.mjs keys its cache of TypeScript's lib files by the compiler target as well as the file, so a program with other options would not take a lib file parsed for another target. The plain-Node icon run draws from a base set before defineIcon again, beside the base set after it. A second instance of the built module, whose base nothing has set yet, gets setIconBase first and is then defined under a tag of its own. The run checks it is a module of its own, so the case cannot pass by drawing the first module's base. The docs say Space on the focused row toggles it, Ctrl+Space too outside macOS, and the JSDoc says "Space (or Mod+Space)". dist/widgets/app-shell/connect/folderSearch.js and .d.ts have had no source since 0c311ae but still shipped. Nothing imports them (source, tests, gallery, scripts, package.json's exports and custom-elements.json name neither), and a fresh build makes neither, so they go.
ww-mw
marked this pull request as ready for review
November 9, 2026 01:57
… not by a regex that backtracks CodeQL flagged both as polynomial regular expressions on library input: /[.\s]+$/ over a source's reason and /0+$/ over a literal's mantissa backtrack over a long run that something else follows, so their time grows with its square (40k characters already took 1.5 s and 0.8 s). Both now scan from the end by index. Two tests read 200,000-character inputs, which the old patterns could not finish inside a test's timeout.
…ee, the slow tests
…ift before Ctrl toolbarItems.ts says its editing buttons' chords are the table's, as the menu labels them, and a test holds the two to it. On macOS both say ⇧⌘Z, but off it the menu says Shift+Ctrl+Z, as VS Code's own webview did (editing-trace.json), and chordLabel said Ctrl+Shift+Z: so the test failed on Linux CI only, and no PR into main had run it there before. The table chords are now written through tableChordLabel, which puts Shift first off macOS; the platform-words test pins Shift+Ctrl+Z.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Every open view branch merged and checked together: shell/parity (#105), open-at (#106), the Folder view (#107), the command line's model (#108), the hierarchy and menu fixes (#109, #110), share links (#111), the MATLAB shell (#112) and compare (#113). It's the commit the desktop app pins to check everything as one (ww-mw/data-explorer-app #44). Merge it after those PRs, when its diff shrinks to the merge resolutions, or in their place.
Merge resolutions
dist/conflicted (compareRows.js on both sides). Rebuilt, and the build matched compare's file.dex-tree-table.ts's styles keep compare's diff-mark block, then the hovered row's 78% muted ink. compare's first-height (ResizeObserver), gap rows,_entryCountand the focus ring come through unchanged.ShellCommandlists compare's three commands, then the sevenmatlab-*.matlab.testfile-menu expectations now include Compare With…;statusBartest: the MATLAB button before a comparison's kind;typedApicounts 65 events from 36 widgets.Checks
npm run verifypasses: 7441 tests, plus check:leak. The build reproducesdist/.buildPropertyGroupsand<dex-context-menu>.show().