The busy logo and the issues list under a card no longer key their CSS off
:has() (#565). On a page of 21,000 elements, those selectors made Chrome
restyle the whole page four times over in one recompute, about 340 ms of
style; it now restyles 36 elements in 4 ms (headless Chrome, same page A/B).
The logo animates while it carries a class that the browser sets on Shiny's
busy and output events, and the issues list stays hidden until the server
writes data-issues onto it.
The first group of a view can hold focus (#462). A click into it used to
read as no focus, so a consumer of view_data could not move focus back into
that group, and on a single-group view never saw focus at all. A view without
focus now opens with no group active, where it used to open with the first
group drawn as active.
views$rename and views$add reject empty or whitespace-only display names
before applying an update (#517).
The navbar is drawn from a list of items, the dock's own controls included,
which an app adds to, reorders or drops from through serve(), as it does
plugins and options. An item, made by navbar_item(), has a UI and may have
a server, which runs once per session under the item's namespace. The call
serve(board, navbar = custom_navbar(item)) appends one to the default, and
navbar takes any function of the board and its plugins that returns
items, such as one that reorders or drops from default_navbar_items()
with [. The defaults are the blockr logo, the plugin's piece, placed by
plugin_navbar_item(), a spacer, the view menu, now set apart by a short
rule, the read-only indicator and the board options. On a narrow bar the
plugin's piece gives way first and the rest keeps its width. An item whose
output renders nothing leaves no gap. The view menu's button shows the
current view's name and a chevron, and the board options button the side
panel it opens rather than a gear (#529).
The blockr logo leads the navbar and is the board's busy indicator, in place
of the spinner ring (#530). While blocks compute, its seven squares fade and
fill again in the order the R is drawn, and the moment the work ends the
logo is whole again. As the ring did, it waits the spinner_delay_ms option
first, slows rather than stops under reduced motion, and leaves a bare panel
switch alone. While it is busy, its "Computing" label is blockr.ui's light
tooltip.
The default Import and Export are one row of quiet 30px buttons, the size
the design spec gives a toolbar (#531). Import opens the browser's file
chooser, without the field label, text field and progress bar of Shiny's
fileInput(). On a narrow bar the names of both are cut short.
Breaking: the navbar's .blockr-navbar-left and .blockr-navbar-right
groups are gone, and the plugin's piece no longer takes up the free space, so
a spacer inside it has nothing to push against. Since serve() hands
blockr_app_ui() the server's arguments as well, the dock's method appends
only its unnamed ... to the page.
The views can show as a line of tabs under the navbar, one per view, with
the "Views as tabs" board option under "Theme options"
(new_view_tabs_option()) or the "Show views as tabs" row at the foot of the
view menu, which sets the same option (#555). The option is off by default
and saved with the board, which then shows the tabs from its first paint. A
tab switches views as a pick in the menu does, and the menu, reduced to its
chevron at the end of the line, stays for managing them.
The block card no longer uses Bootstrap (BristolMyersSquibb/blockr.ui#85).
Its sections (control, inputs, preview) fold in the browser on the
toggle's click instead of through a server round trip to bslib's
accordion, so the preview's eye answers in a few milliseconds instead of
50 to 150. The cards of views not on screen wait in plain divs off the page
instead of Bootstrap offcanvases, the warnings and messages under the
preview fold in a native <details>, and the card is the dock's own
.blockr-block-card instead of Bootstrap's .card. Bootstrap stays on the
page for now.
A locked board can leave parts of its layout to the reader. With the
lock_resize blockr option set to FALSE, a reader can resize panels by
dragging the borders between them, to make room for a wide table, and with
lock_rearrange set to FALSE, rearrange them by dragging their tabs.
Nothing a reader changes is saved: reloading the board brings back the
layout it was deployed with. Closing and adding panels stay off, and by
default both stay locked as before (#421). The border of a rail can be
dragged either way, as dockview's lock does not reach it
(dockview/dockview#1671).
The card's preview toggle and "…" button and the Edit board extension's
buttons draw blockr.ui's small icons instead of Font Awesome's, through
blockr.ui::small_icon() in place of shiny::icon()
(BristolMyersSquibb/blockr.ui#85). The "…" button's dots are horizontal, as
the design system draws them.
The dock draws a block's mark as blockr.ui's, in the sizes the spec gives it
(#495). The block header calls blockr.ui::block_mark() at 32px, which the
compact header shows at 20px, and the cards of the link and stack menus call
it at 24px. The rows of the "+" and "Add panel" menus give blockr.ui's menu
the block's category, from which it draws the same mark at 24px, and so does
the block picker of board_block_select(), in its list and in its field.
The picker no longer draws tiles of its own, and no longer reads the
icon_style option. Each mark takes its colour from its category's token.
The dock's own .blockr-block-mark rules and their --blockr-dock-cat
property are gone, as are the cards' tinted tiles and their copy of the
palette. The rules also matched the menus' marks, which came out as 32px
squares on a grey tint. The header's glyph is 18px, up from 16px.
Both blk_color() and blk_icon_data_uri() are deprecated (#495). The
category colours are blockr.ui's, and blockr.ui::category_color() looks
them up. The deprecated blk_color() calls it, so its colours now come in
lower case. For the mark as an image, blockr.ui::block_mark_svg() draws it
from a block's glyph and category. The color column of blks_metadata()
stays, now from blockr.ui::category_color().
Renaming a block sends the new name to the server on Enter or when the field loses focus, not on every keystroke. Each keystroke was a board update, and while typing those piled up on the server.
The rails of a board's views open and close together. Collapsing or
expanding the rail on one edge of a view does the same on every other view,
and a view visited for the first time opens with its rails the way the views
already visited show theirs. Only a rail holding panels takes part. The
"Sync rails across views" board option (new_sync_rails_option(), in
dock_board_options(), on unless the sync_rails blockr option says
otherwise) turns this off, and switching it back on brings every view to the
one on screen. A board saved before this release has no such option, so its
views keep their rails as they were left (#480).
The block's "…" menu is blockr.ui's Blockr.menu, driven from the
keyboard: the Controls toggle, then Rename, Append block and Copy block ID,
and Remove block after a divider. The preview and a block's own control
keep their buttons in the header. A control's button shows its icon, or its
label where it has none, and is named by its ctrl_label ("Control" without
one); the dock no longer applies a control's ctrl_class to it. The dock no
longer depends on shinyWidgets.
Adding, appending, prepending and inserting a block open one menu in place,
with a filter box and one row per block type, instead of the block browser
sidebar. "Add panel" is the same menu over the board's blocks not in the
view, and its dialog is gone. An action's trigger can name where its
gesture happened (at, see new_action()): the menu opens there, and
under the navbar when nothing is named.
"Manage views" turns the views menu into an editor: drag a view by its grip to reorder, click a name to rename it, remove a view after a question in its row, and add an empty "View N" with "New view", all without a dialog.
The board options sidebar lists the option categories, and a row opens that category's page. The header then shows a back arrow and the category's name, and the arrow or Escape returns to the list. The Bootstrap accordion and the rule above it are gone; "Show code" is the list's last row.
A "Compact" board option (new_compact_option(), in dock_board_options(),
off by default) turns every block header into an eyebrow line: a small
tinted mark and the name in muted capitals.
A first visit to a view no longer re-checks every block's frozen state per
card mount. A card's reported sections depended on the session's whole input
name set, so every new input on the board woke every block's visible, and
freeze_hidden_inputs() re-read all of them: 21 to 43 runs over ~90 blocks
per first visit. The key test now runs under isolate(); reading the section
input itself already fires when the card first reports.
Testing a block for controls renders their markup without resolving their
html dependencies, which cost more than the markup once every control
carried its own set (resolveDependencies 1.4 s to 0.8 s over a short
session).
Cards and extensions parked off screen (views you have left) are no longer
styled or laid out by the browser (content-visibility: hidden on the closed
offcanvas pools). On a 90-block board they are half the document; one DOM
insertion goes from 106 to 11 ms and a return view switch spends 0.8 s instead
of 2.1 s on style (loaded container, same page A/B).
The dock reads its colours, radii and surfaces from blockr.ui's design
tokens, so a board follows blockr.ui's dark scheme: the dockview frame and
tabs, block headers, sidebars, the block browser and the block menu. Font
sizes, weights and families read the type tokens.
The options of dock_board_options() now include the light/dark switch,
light by default, and core's thematic switch, off by default, which lets
plots take the board's colours.
The block header drops its subtitle: a 32px mark in the block's category colour carries the status dot, and the block type, with the package as a badge, is the mark's tooltip. The title is 16px and wraps to two lines. The controls sit just under the header with no rules around them; one rule separates them from the preview while both are open.
The dock's chrome (block header, navbar, view menu, sidebars) shows
blockr.ui's light-card tooltip (Blockr.tooltip) in place of the browser's
native one. The "…" menu and the board options gear have one. The markup
carries each tooltip as data-blockr-tooltip rather than as a title, and
an icon-only button is named by an aria-label. Markup an app adds to the
chrome gets the light card the same way; a title there stays native.
A parked block's status badge is drawn from the status blockr.core now
reports for it in place of dormant: the outcome of the block's last
check, stale once that is out of date, or unevaluated without one.
The block_status_badge() helper no longer returns NA, which it gave
for dormant to tell a persistent renderer such as the blockr.dag node
to keep the badge it drew last. A parked block that failed shows the
failed badge without being visited, and unevaluated, like ready,
carries none. Requires blockr.core with the unevaluated status (#485).
The dock now states its evaluation demand as the blocks it holds eager,
in place of the per-block required channel blockr.core has retired.
Its board callback makes the board lazy by returning eager() with the
active view's front panels, which core seeds as the dock's eager set
before the first flush. From there, what the dock has on screen travels
as an eager update under the same owner label -- one payload per view
switch where the retired channel took a write per slot, and a card that
leaves the screen is released by its absence from the set rather than
by a second write. Requires blockr.core with eager() (#417).
A card the dock has built but is not showing no longer carries
construction demand of its own. The retired required channel had a
third state for it, which paced those blocks into core's priority
construction lane; nothing replaces it, so the blocks behind an
unvisited tab are built by core's background pass in its own order and
fronting one holds it eager. First paint therefore waits on fewer blocks
than before (#417).
A new insert_block_action puts a block into an existing link
(#459).
Triggered with a link id, it offers the same block browser as the add and
append flows; committing a block C for A -> B drops that link and wires
A -> C -> B in one update. The far end takes the split link's place, not
merely its slot, which is what makes this an insertion rather than a
rewire. Position is what matters, for named and blank entries alike:
sync_dot_args() drops every key and re-adds them in the board's link
order, so a link merely appended lands last and slides every sibling after
the split one up a place. rbind(first = a, second = z) came back as
rbind(second = z, first = c), rows swapped, even though the name was
preserved. The far end is therefore placed with the before component
blockr.core gained for this, and it keeps inheriting the split link's
input on top, which preserves a named entry's binding as well as its
position. The near end lands on a free slot of the new block, with the
usual picker when there is more than one to choose from. Candidates are
filtered as for append, since the new block has to be able to receive from
the source, and both new links offer an id field with an auto default, as
the add, append and prepend flows do. Unlike append, the panel closes even
when pinned: the gesture consumes the link it was triggered with, so there
is nothing left to repeat it against.
A grid that places the same panel more than once is now rejected when validated, rather than surviving to the render cast. A grid says where each panel goes, so two spots for one panel express nothing, and the check spans both halves of one: twice in the tree, twice inside a single rail, or once in each of two rails. The tree/rail overlap that canonicalisation prunes has a principled winner -- the rail claims the panel -- while two such spots have none, so this rejects rather than quietly dropping one. Previously the duplicate reached the render cast and aborted with blockr.core's "Block IDs are required to be unique.", which names blocks rather than the layout and fires far from whatever wrote the grid. Every producer routing through the views delta -- a hand-written grid, a restored board, a views$grid write, a views$add entry -- inherits the check (#464).
The blk() / ext() placement hint gained a rail key, so the add and move panel-op verbs can park a panel on a view's left or right edge. A rail used to be authorable only as a view's birth geometry, through rail() inside a dock_grid(), which left the user's own drag as the only route into one on a view already on screen. The key names an edge rather than an anchor, so it excludes near / side: a side is a direction relative to a near anchor inside the splitview while a rail position is an edge of the whole view, and both spell left and right (#461).
A block panel opened from an extension -- a node click in the DAG, a row click in an outline -- no longer lands as a tab on top of the extension it was opened from. An add that carries no placement hint now reserves every group holding an extension panel, read off the panel id rather than off the hardcoded dag key behind the undocumented blockr.visible_extensions option, so an extension mounted under any other key is reserved too. The reservation tests membership rather than the front tab, which is what made the misplacement look intermittent -- the same click placed correctly or not depending on which tab of the extension's group happened to be open. The option is gone, and nothing has to opt in (#250).
A rail's width now survives a viewport too narrow to render it. A rail is sized in pixels and is the low-priority view of dockView's shell splitview, so a dock that cannot fit it squeezes the rail rather than the centre -- and hands the space back to the centre, not the rail, once there is room again. The settled-echo mirror used to commit that width, which left the board holding the narrowest viewport it had ever been opened at, and every later restore came back at that. It now takes a rail's width from the client only across an echo that left the dock's own width alone -- a rail sash moves the boundary between the rail and the centre and leaves that total untouched, while a viewport change moves it -- so a sash drag still persists and a resize no longer rewrites what the user set.
The mirror also ignores the empty dock a view echoes before its restore reaches it. That echo places nothing, and committing it blanked the view's stored geometry, leaving the arrangement to be rebuilt from whatever the client rendered next -- which for a rail is a width, not the same width back (#457).
On a narrow viewport, a view's nested grid now flattens into a single
vertical stack: every tab group survives as its own row, railed ones
included, and the page scrolls from one to the next instead of columns
running off-screen. A row keeps the height the wide layout gave it -- so a
group the author sized down stays short rather than being padded out --
capped at blockr.narrow_group_fraction of the viewport (0.8 by default, a
fraction in (0, 1]). The width is read once, at startup, so reflowing takes
a reload.
The collapse is opt-in and off until a deployment sets
blockr.narrow_breakpoint. Setting it to Inf collapses at every width,
which is how a board meant only for phones asks to always stack. An unusable
value aborts rather than falling back to a default -- anything under 50 px,
NA, or a string that is not a number -- since a deployment that sets a
breakpoint has an intent, and silently rendering the other layout would hide
the typo until someone opened the board on a phone.
The stack is a render and nothing more: a narrow session writes no geometry back, so the board keeps the layout a wide viewport restores to and a save from a phone still persists it (#413).
Blocks and extensions can now sit in a rail -- a tab group pinned to one edge of a view, out of the splitview, rather than a grid cell competing with the panels for width. Every board offers a left and a right edge; a rail is written among a view's grid children with rail(), and the default board parks the extensions on the left. Which rails a dock offers is a constant, so a grid only records which are populated -- an empty rail is invisible, and a board stored before rails existed offers the same edges as any other. A railed panel is absent from the grid tree, so the placement walks are untouched and a view's members are the union of the two, with membership still authoritative for which panels exist while the tree and the rails only say where. Dragging a panel into or out of a rail is stock dockview, and the arrangement rides the settled-echo mirror and save_dock() / restore_dock() like the rest of the grid does (#431).
A rail's visibility is derived rather than stored: a rail holding panels is shown, an empty one is hidden. That rule replaces a pin concept and a persisted flag, and it matches the invariant the grid already keeps. Since a hidden rail has no hit area, dragging toward its edge reveals it -- collapsed, so an empty rail shows its bare strip rather than a full-width empty pane -- and the drop expands it. A drag that ends anywhere else leaves the derived rule to hide it again. Whether a rail is collapsed is stored, since unlike visibility it cannot be derived -- an expanded rail and a collapsed one hold the same panels -- so a board comes back the way it was left.
The --blockr-* design tokens and the host-app-wide theme layer now live in
blockr.ui, which this package imports and attaches through
blockr.ui::theme_dep(). Nine other packages style themselves from that
vocabulary, two of them without declaring a dependency here, and the theme
layer restyled the whole Bootstrap surface -- typography, labels, form
controls, selectize, buttons, tooltips, popovers and the DataTables chrome
-- of every app that loaded a docking layout manager. Neither the vocabulary
nor the theme is this package's to own. What stays is the docking chrome,
every rule of it scoped to markup generated here (#407).
Block card chrome that was built on every render and then hidden by the
stylesheet is gone: the icons and titles fed into the block card's accordion
headers, which display: none also keeps out of the accessibility tree, and
the export button's icon in the board offcanvas. Dropped with them is a
.popover-header rule that hid a header no popover here renders -- and, the
stylesheet being host-app-wide, any header a consumer's own popover rendered
too. The companion .popover .btn-close rule stays: bslib injects that button
into any popover whose trigger does not include "focus", so it is built on the
client and cannot be dropped at the source (#72).
Removing blocks that are on screen no longer kills the session with
"attempt to apply non-function". Cutting a whole stack hit it every time.
The visible-axis observer drove both card axes straight off the client's
layout echo, which still names a panel for a tick after core has dropped
its block, and mark_cards_rendered() called the dropped slot. The echo is
now reconciled against core's visibility slots once, where it is read, so no
consumer sees a block the server has already dropped (#387).
A block card whose sections the user has all hidden now comes back hidden,
and freezes while its controls are off screen. The toggle widget reports
NULL for an empty selection, which is the same value the server holds
before the card has reported at all, so "the user hid everything" was
stored as -- and read back as -- "nothing saved": the card reopened both
sections. The same conflation left the block unfrozen, since the freeze
gate reads a non-NULL report to mean the card has landed. The card now
reports an empty selection as character(), telling it from a card that
has yet to report, and both halves follow. A board saved before this change
carries a genuine NULL and still restores with both sections open (#426).
A restored block card paints its saved sections open straight away,
instead of opening every section and collapsing the hidden ones a
moment later. The card rendered its accordion open unconditionally and
left a server observer to correct it, which it could only do once the
client had reported the toggle widget's value back -- on a four-block
board that correction landed some five seconds after the card
appeared, so the user watched the board settle into its saved shape
rather than opening in it. A locked dock now renders no toggle widget
at all: it was there purely to drive that correction, hidden behind
display: none yet still a live input a client could set (#418).
Two selectize widgets that had lost their callers are gone. Adopting
blockr.ui's link-menu module in the add-link flow deleted the only call to
board_select(), and block_registry_selectize() had no caller either.
Exported in their place is board_block_select(), the block picker the
board itself uses wherever a block is chosen -- the rich selectize listing
each block by icon, name, ID and defining package -- returned with the
styling its option rendering requires already attached. Every board-block
picker in the package now builds through that one function, so a consumer
outside it gets the widget the product uses rather than a reconstruction
of it (#427).
Switching to a view before the board has settled no longer leaves it
hopping between views for good. The nav reported the server's own
sendInputMessage("view_nav", ...) straight back as a gesture, and with
two switches in flight the first push's echo landed after the second had
been applied, missed switch_view_observer()'s client_active guard and
was taken for a fresh switch -- whose push echoed in turn. Every hop
re-evaluated and repainted the whole view, so the board looked like it
was reloading itself and only a page reload got out of it. The nav no
longer reports a programmatic update at all: it forgets Shiny's cached
input value instead, so a later click on the view the server pushed away
from is still reported. A newly added view is no longer marked active on
the client either, which the echo was the only thing correcting: an add
whose delta does not ask to navigate -- an extension creating a view in
the background -- now leaves the active view alone (#424).
A block with nothing to configure no longer carries an empty "Block
inputs" section, nor the toggle that opens it. Core's new_block() ui
default renders no markup at all, so a card for a block configured
entirely by its links -- rbind_block, say -- offered a control that
opened onto a blank panel (#69).
Extension state now reaches the saved board. Every extension serialized
an empty payload while still writing its object and constructor, so a
save looked complete yet carried none of its extensions' state and a
restore rebuilt each extension from constructor defaults. An outline
came back with no annotations, so every block fell to the
report = TRUE default -- a board saved with one block in the report
came back with all of them in -- and a hand-arranged dag lost its node
positions (#386).
The stack sidebar picks a colour with a native <input type="color">
beside the hex field, in place of the hand-rolled hue / lightness
sliders. The sliders reached only a fixed-saturation slice of the colour
space -- no black, no white, nothing muted or fully saturated -- and a
hex value typed from outside that slice was accepted but then silently
rewritten by the next drag. The native input gives the full gamut, plus
the platform's own dialog, eyedropper and keyboard handling (#396).
A block whose inputs changed while it was parked now carries a muted
grey status badge instead of none. Core's sixth eval status, stale,
fell through block_status_badge() to "no badge", so a block holding
an out-of-date result looked identical to a healthy one on both the
dock card icon and the blockr.dag node. A stale block also drops the
red failed badge it would otherwise keep from error conditions
recorded before the change: those describe inputs it no longer has,
and it has not re-run since, so the upstream edit may equally have
fixed the failure as caused it (#408).
New export sidebar_owned_by(), which reports whether a given action
currently holds one of the board's sidebar panels -- NULL when it
does not, otherwise the panel plus whether it is open and pinned. It
composes the ownership stamp itself, so a consumer that re-fires an
action on a new selection can ask "is the form I opened still on
screen?" without knowing which panel that action fills, which panels a
board mounts, or how a stamp is spelled. Previously the only way in was
to read the panel's input value directly, which meant naming dock's
panels in the consumer (#399).
A sidebar panel now reports which module wrote the body it is showing.
Every show_sidebar() stamps the writing module's namespaced id on the
panel -- NS(<board id>, <action id>) for a board action -- taken from
the session the call runs in, so the stamp follows the write rather than
the gesture and covers paths no consumer can observe, such as a holder
of the trigger bundle firing a shared-panel action directly. It comes
back as owner beside open and pinned in the panel's input value,
letting a consumer that re-fires an editor on a selection tell whether
the content it put there is still on screen. Filling a panel takes it
over, so nothing has to declare which panel it writes to release it.
dock's own auto-close handlers (edit stack / link / inputs, which close
when their target leaves the board) now gate on this, and no longer
close a form another action has since written into the shared panel
(#391).
A pinned stack / link sidebar now refreshes in place after a commit
rather than being torn down and rebuilt, so search text, scroll
position and anything the user entered that the commit did not consume
survive it. The stack menu's name / colour / id form is server-rendered
against the board to make that possible -- it still offers a fresh
stack id after each create -- and with nothing left to rebuild, none of
the four post-commit paths defers its close to session$onFlushed()
(#393).
A select verb in a view's views$mod update is now applied when
that view's dock is built for the first time in the same update that
carries the select -- for instance an update that activates a
never-opened view. Previously the panel-op observer took the select as
its ignoreInit value and dropped it, so the board switched to the
view but the requested tab was not brought to the front. The pending
select is now folded into the grid the fresh dock restores from, so the
tab is fronted on first paint (#324).
New exports for downstream consumers that translate between bare
block / extension ids and dock's panel-id scheme: the class predicates
is_dock_panel_id(), is_block_panel_id() and is_ext_panel_id(),
and as_panel_ref(), which resolves a bare id (or an already
wire-prefixed one) to a blk() / ext() ref against a board's block /
extension id sets, block-first with a hard error on a cross-namespace
clash (#374).
"Show code" on a deferred board
(background_construction_delay = Inf) no longer permanently blanks
the cards of a view first visited after it. The exporter marks every
block required so the script covers the whole board, and the dock's
card ledger -- read off that same required channel -- mistook the
export's demand for a built card, so the first visit to the view
skipped the build and left its panels empty. The dock now reads its
build ledger off core's visible channel, which blockr.core makes a
logical three-state axis (NA never built / FALSE built off screen
/ TRUE painted), so a required write can no longer masquerade as a
built card (#377).
New edit_inputs_action: a per-block sidebar listing every incoming link
as an ordered list, so a block's inputs can be managed together rather than
one edge at a time. For a variadic block each row is a positional slot -
drag to reorder (each row's source and name move together to its new slot
via links$mod, so ...args comes out in the new order), rename inline
(positional <-> named), or remove; an "Add input" block picker below the
list appends another positional slot when a source is chosen. A finite
block's rows are its declared ports, each a block-browser selectize that
picks, redirects or disconnects that port's source. Reorder keeps every
link's id, so there is no id churn and no new core verb. Surfaces such as
blockr.dag can trigger it for a selected node.
A panel id in a dock_grid() or view that resolves to no block or
extension on the board now aborts at new_dock_board() rather than
being dropped in silence. Such an id -- a typo, or an extension's old
class-derived name (extensions are keyed by their mount name since the
ids became container-owned) -- used to empty the view, booting the
board blank with no error, warning, or log entry. Restoring a saved
board is unchanged: a member or grid leaf whose block is genuinely gone
still self-heals (#375).
Block card sections (inputs / outputs / control) are styled from the
stylesheet, keyed on each panel's stable data-value, rather than
rebuilt per card with htmltools::tagQuery() at UI-build time. The
markup renders identically but the cards build about a third faster --
a cost that scales with the number of blocks on the active view, so it
cuts noticeably into the initial app render (#214).
Closing a dock panel no longer aborts the board update when the same tab is
closed twice in quick succession. The manual-close plugin leaves a tab's x
in place until the server round-trip removes it, so a rapid double click
re-fires the close for a panel that is already gone; that stale removal is
now dropped rather than failing view-membership validation (#362).
Blocks on a dock group's background tabs render again. dockView mounts a
group's non-front tabs lazily, so a block card's move-element could arrive
before its panel existed and be dropped, stranding the card in the offcanvas;
and a bare tab switch did not mark the newly-fronted block visible. Both left
non-front tabs blank. A dropped move is now stashed and replayed when dockView
reports the panel active (dockViewR's dockview:active-panel event), and the
visible mark follows the client's live active-panel signal, so selecting a tab
paints its block (#361).
Dock extensions can now carry structured, model-facing metadata: the
description argument of new_dock_extension() accepts a new_ext_meta()
object documenting each externally controllable variable (with an optional
type schema and worked examples) and how to drive the extension, read back
with ext_meta() and the per-component ext_desc(), ext_args(),
ext_examples() and ext_guidance() accessors. A bare string keeps working
as the free-text summary; the earlier extension_description() accessor is
deprecated in favour of ext_desc() (#359).
The navbar busy spinner keeps turning when the browser reports
prefers-reduced-motion: reduce, at a slower 1.6s turn instead of 0.7s.
It previously dropped the animation entirely, which left a fully styled
ring frozen in the navbar and reading as a hung session. Windows maps its
"Animation effects: off" setting (a common managed / VDI default) onto that
preference, so on those machines the spinner never moved.
Idle, the navbar busy spinner is now a faint, closed ring rather than a gapped three-quarter circle that read as an oversized "C" wherever it sits. The darker arc that signals motion is painted on only while the board is busy; at rest the ring is a single muted colour and recedes into the navbar.
Views can now be reordered from the nav dropdown: each item carries
up / down controls beside its rename and remove actions. Order is board
content, so the move travels through the update lifecycle as a new
views$order delta (a total permutation of the view ids) and survives save /
restore; the server applies it and pushes the settled order back to the nav
(#351).
A served board now honours a ?view=<id> URL query parameter: it opens on
the named view instead of the board's default active view (matching by
stable view id, the immutable handle). An absent or unknown id falls back
to the default, so existing links are unaffected (#323).
New edit_link_action: a sidebar editor for a single existing link. It can
rename the link's input (turning an unnamed positional slot into a named
one, or changing an existing name), switch the input slot on a finite
target, and redirect the link's source or target - under the same
acyclicity, eligibility and input-name uniqueness rules the "Connect ..."
menu enforces, with the block pickers rendered like the add-panel picker.
The link keeps its id across the edit. Surfaces such as blockr.dag can
trigger it for a selected edge.
The "Connect ..." sidebar and the block browser's append / prepend forms now let a link into a variadic block carry a name: an optional "Input name" field appears for variadic targets (leave it blank for a positional slot). A supplied name must be unique among the target's inputs, per blockr.core's name-or-position model.
resolve_free_input() now resolves a variadic link target to an empty
(positional) slot instead of a generated "1", "2", ... name, aligning
the "Connect ..." sidebar with blockr.core's name-or-position variadic
model (and with blockr.ui's link menu). An integer input name is treated
by core as a named argument, and downstream consumers such as
blockr.io's Download/Export blocks name files and Excel sheets by the
link input verbatim, which surfaced as 1.csv / 2.csv exports.
Off-screen views' block cards -- built on first visit rather than at
startup (#272) -- are now built with the plugin set passed to serve(),
not the board default (#331). ensure_block_ui() re-derived the edit /
control UI from board_plugins(), which omits any custom ctrl_block,
so a block's control toggle (the AI "sparkle" when the served plugin is
blockr.ai::ai_ctrl_block) showed on the initially-active view but was
absent on every other view's cards. The served plugin set now rides
active_dock alongside the visibility channel, so the deferred build --
the view switch and the add-panel path -- sees the served ctrl_block.
Locked mode is now a server-side trust boundary, not just UI hiding (#127,
#135, #136). is_dock_locked() reads blockr.core's blockr.locked option
(renamed from blockr.dock_is_locked), so one flag drives both core's update
/ option gate and dock's UI hides; a deployment setting the old option must
switch to blockr.locked. Hiding a block's input section -- and every block
on a locked board -- now drives core's per-block frozen channel: the
block's expression is pinned and its inputs are no longer consumed, so a
forged Shiny.setInputValue behind the hidden or read-only controls reaches
nothing (upstream data still flows, and showing the section again thaws it).
View switching on a locked board is driven client-side, as core's gate
rejects the active-view update; the board-options accordion (#135) and the
empty view's "Add panel" prompt (#136) are dropped when locked.
At startup the board now builds only the active view's dockView;
off-screen views' docks are created on first visit rather than all up
front (#304), mirroring the card deferral below. Building every view's
dockView left the active group pointing at an off-screen view during the
startup restore burst, transiently dropping the visible view's blocks and
starving first paint. reconcile_views() now builds only the active
view's dock and defers the rest; a view without a live dock contributes
its board-stored grid to view_data() rather than blocking it.
A view's visible-axis mark -- the client-confirmed paint blockr.core's
background-construction gate waits for -- now rides the active view's live
dockView layout echo, the same signal the required axis already tracks,
rather than a one-shot snapshot of the grid's stored active tab (#304,
#328). A group's front tab is client-owned (the last-added tab wins) and
can disagree with the grid, so marking the snapshot left the on-screen
block suspended and blank on first load while a hidden back tab was marked
painted. Sourcing the mark from the painted layout follows whichever tab
dockView actually fronts and re-marks on a tab switch, so the on-screen
block renders.
At startup the board now builds only the active view's block cards;
off-screen views' cards are built on first visit rather than all up
front (#272). board_ui() rendered an edit card for every block across
every view into the static offcanvas mount, so first paint scaled with
the total block count, not with what is on screen (~20s of renderTags
on a 99-block, 12-view board). It now renders only the active view's
cards and defers the rest; switch_active_view() (and the active-dock
panel-op path) inserts a view's cards the first time it is shown, and
core's required channel doubles as the build ledger so a revisit never
doubles a card.
Block visibility is coordinated with blockr.core (>= 0.1.4) over its
two-channel visibility interface: a per-block required channel the
dock drives (TRUE on screen, FALSE built but off screen) and a
visible channel it writes with a view id once the client has painted
that view. This gives blockr.core an explicit "the initial view is
painted" signal to gate its background block-server construction on,
instead of inferring readiness from result-quiescence.
views$mod update payload
(add / rm / move / select), with panels named by the new typed
references blk() / ext() instead of wire-id prefixes. Breaking: the
old set-replace membership form is retired.views$mod grammar gains a resize verb --
resize = list(blk("a", size = 0.3)) sets a panel's group size along its
splitview axis (a ratio in (0, 1)), delivered through dockViewR's set_size
proxy. Like move / select it is client-owned geometry: pure delivery,
captured by the grid mirror, no board write (#320).ext() target.extensions bundle keyed by
extension id; the new exported extension_ids() resolves a class to the
runtime id(s) the container assigned.views grammar (compose
active + select) rather than the retired live dock handle; the exported
show_panel() is removed.block_status_badge(),
shared with blockr.dag so the dock card icon and the DAG node badge render
identically; the dock dot now also reflects render-phase errors.dock_views structure collection (read with
board_views()) and a separate NULL-valid dock_grids geometry slot
(board_grids()), each grid validated as a subset of its view's membership.waiting or
unset block shows a dedicated placeholder instead of a generic warning, and
a colour-coded dot in the card header marks waiting, unset and failed
blocks at a glance.blockr.spinner_delay_ms, default 200 ms;
0 to disable) holds the transition to the busy state so a sub-threshold
flush no longer flashes it (#345, #355, #360).view_data, the live all-views layout reactive
that serialization also reads (NULL until every view has reported once, so
req() it); the active-view dock handle is retired from the extension
surface.board_layouts is removed, and the live layout is read on demand instead.view_data(), the
live layout serialization reads, no longer stays stuck at NULL for the
whole session.argument is of length zero.blockr.ui menu modules (card-list pickers with search and inline editing),
replacing every per-field Shiny input; the link menu adds bidirectional
source / target picking and the stack menu an inline colour picker. The block
browsers are pre-rendered and toggled rather than rebuilt on each open, and
the dock-side *_sidebar_body() bodies and spec helpers are removed.constructor$version) rather than sniffing the payload shape, keeping
shape discrimination only as the fallback for version-less payloads.apply_board_update.dock_board() is a
pure reducer and all live view surgery runs in one reconcile pass driven by
the committed board. augment_board_update.dock_board() is now idempotent,
fixing a view-add loop.dock_layouts is keyed by id, the name is read and
written via view_name() / view_name<-(), and the views delta gains a
rename slot. In new_dock_board(layouts = list(...)) the list name is the
view's id, so producers that addressed views by name (e.g. blockr.assistant)
must switch to ids.dock_layout now has format() / print() methods that render its
arrangement as an indented tree; panel ids print without their wire prefixes
unless bare = FALSE.views slot of the board_update payload is a structured delta (add /
mod / rm / active) instead of a wholesale dock_layouts replacement,
composing atomically with blocks / links / stacks. UI-driven layout
changes (panel close / add, drag-resize, view CRUD) route through this
lifecycle and are debounced (250 ms), and removing a block drops its panel
surgically rather than clearing the active view. Requires
blockr.core (>= 0.1.3).Added prepend block action.
Define multi-view boards by passing a named list to
new_dock_board(layouts = ...):
layouts = list(
Analysis = list("block_1", "block_2"),
Overview = list("dag_extension")
)
Mark an arrangement as initially active with dock_layout(..., active = TRUE):
layouts = list(
Analysis = list("block_1", "block_2"),
Overview = dock_layout("dag_extension", active = TRUE)
)
If none is marked, the first one is used. The board's initialise_layout
normalises each slot to a dock_layout (storing the arrangement only),
and stores the result as a dock_layouts collection.
Breaking changes to the layout API:
new_dock_board()'s layout parameter to layouts (and the corresponding board field), since boards now hold a dock_layouts collection.dock_layout(brd) (and setter dock_layout(brd) <-) to active_layout(brd) / active_layout(brd) <-.board_views(brd) to board_layouts(brd), and the corresponding setter dock_layouts(brd) <- value to board_layouts(brd) <- value.dock_layout is now the per-view arrangement type. dock_layout(...) constructs one from a nested list of block / extension IDs and accepts orientation, sizes, and active arguments. The previously-exported "fully-resolved" dock_layout (grid + panels wire shape) is gone — panel content is derived from the board's blocks and extensions on demand at the dockview boundary, so per-view storage shrinks to just the arrangement and panel definitions no longer duplicate across views.panels(..., active = NULL) for tabbed leaves with an explicit open tab, and group(..., sizes = NULL) for nested branches with explicit ratios. dock_layout() itself also accepts sizes = for root-level ratios and orientation = for the top-level split direction.dock_view(), dock_grid(), is_dock_grid(), and as_dock_grid(). Use dock_layout(...) (or the new panels() / group()) for the per-view spec.default_layout() → and kept the name default_layout(). It now returns a dock_layout (arrangement only) — the previously-exported default_grid() (panel-ID form) is gone.create_dock_layout() (renamed internally to resolve_dock_layout()).dock_layouts() constructor. The user-facing input shape for new_dock_board(layouts = ...) is a plain named list — the dock_layouts type is the resolved collection that the board holds internally. is_dock_layouts(), as_dock_layouts(), and validate_dock_layouts() remain exported.new_dock_layout(); use dock_layout() instead.view_ids() and view_can_crud(). Both were internal helpers exposed by accident; renamed to layout_ids() and views_can_crud() respectively to align with what they operate on.dock_layout decoupled from dockview's internal tree. The persisted shape is a flattened recursive spec: the top object carries orientation, children, optional sizes, and optional focus (the panel with current focus); a child is a bare string (single-panel leaf), a {panels, active?} object (tabbed leaf), or a {children, sizes?} object (nested branch). Sizes are ratios (auto-normalised from dockview's pixel sizes); even splits omit sizes; the default open tab omits active; focus on the first leaf omits focus. focus round-trips the focused group (dockview's activeGroup) by naming a stable panel rather than the regenerated group id. Legacy payloads (with the dockview-shape grid field) load via a shape-discriminated reader. Producer-version routing is tracked in #153 (depends on blockr.core forwarding ... in blockr_deser.list).as_dock_layout() coerces a dock_layout (identity), a board (its active layout), or a spec list to a dock_layout; as.list() of a dock_layout returns that spec list. The R object ↔ JSON string boundary uses explicit verbs: layout_to_json() / layout_from_json(). Both as_dock_layout(<list>) and layout_from_json() take optional blocks / extensions to resolve bare IDs and validate. layout_panel_ids() / panel_obj_ids() inspect the panel / object IDs a layout references. The dockview wire format and its converters are not part of the public API — only the dock_layout object, our JSON, and the spec list are; as_dock_layout() rejects a dockview grid-shaped list.