@mosaicajs/components 0.1.0-rc.4 → 0.1.0

package/dist/explorer.js

@@ -131,70 +131,31 @@ const TABS = [
     { sheet: 'detail', icon: 'info', label: 'Item', panel: 'detail' }
 ];
 /**
- * The map with its status strip, toolbar, field cards, display settings, layers, selection and item
- * card, laid out together. It builds its own store from `token` or an `authorise` property and
- * `viewer-url`, the page's own origin where unset, or from `viewer-url` alone for an open server,
- * or takes a `store` property, and provides it by
- * context to everything inside it, including elements a host puts in its slots.
+ * Use the explorer when you want a working map page without arranging the elements yourself. It
+ * gives the viewer a map with the filter panel, the status strip and a Layers popover, and it opens
+ * a card when they pick an item or a cluster or select a region.
  *
- * The heading names what is shown: `dataset-title` where the host sets one, with the view's name
- * under it, else the view's name alone. A view's name that is only its id is left out. With
- * several views the view's name is the view choice.
+ * Most of these parts have a slot, so you can put your own element in place of one of them. For a
+ * different arrangement, lay out the separate elements yourself.
  *
- * The left holds the heading and the filter panel (`<mosaica-filter-panel>`): what the cards count,
- * In view or Highlighted beside All matching, the clauses applied as chips with Clear all, one
- * `<mosaica-field-card>` per field, and Add field. `layout="docked"` puts them in a sidebar left of
- * the map; `layout="overlay"` puts them in a card over the map's top-left, which scrolls inside
- * itself when tall. The map's tools sit at the top-left of the map, right of the card in the
- * overlay layout, with a Layers button beneath them. The status strip sits in the map's
- * bottom-right.
+ * The explorer builds its store from `viewer-url` and `token` or `authorise`, unless you give it
+ * one in its `store` property. Every element inside it uses that store, including the ones you put
+ * in its slots.
  *
- * Picking a point opens its item card beside the point, joined to it by a short leader: on the side
- * with most room, clear of the cards over the map, the map's tools and the Layers button, following
- * the point as the map pans and zooms, hidden while the point is off the map, and clear of the
- * other cards beside points. Where no side beside the point is clear, the card goes to the clear
- * place nearest it. The card shows the headline, the `subtitle-field` field, the `card-fields`
- * fields (else the first three), "Show all N fields", and Open where `open-url` or `open` says what
- * it does. Show all grows the card as far as the map's height and the same things allow; past that
- * the card scrolls. Picking another point replaces it unless Pin was pressed, which keeps it open;
- * Close or Escape closes it and drops the selection, and a click on the map that finds nothing does
- * the same for the card that is not pinned. Tab from the map goes to the card, which is named by
- * its item's title and gives focus back to the map as it closes. A picked cluster's card behaves
- * the same way. While a region is selected its card stands in the map's top-right corner, and where
- * the map holds no position for the selection, as after following an item into another view, the
- * item's card goes there too.
+ * `layout="docked"` puts the heading and the filter panel in a sidebar beside the map, and
+ * `layout="overlay"` puts them in a card over it. When the bundle offers more than one view or
+ * group of views, the heading holds the view picker so that viewers can switch between them.
  *
- * The Layers button opens a popover in four sections. Points: whether the points are drawn; Most
- * points, a slider from `budget-min` to `budget-max` on a log scale that sets the store's budget
- * when it is let go (`Store.setBudget`); while a `nested` or `dag` layer is drawn, Most clusters,
- * a slider from `cluster-budget-min` to `cluster-budget-max` on a log scale that sets the most
- * clusters such a layer is cut to when it is let go (`Store.setClusterBudget`); what sizes the
- * points; and their opacity. Size by lists
- * None and the number columns the points arrive with. Under None one Size slider sets every
- * point's radius, which `hide-size` leaves out; under a column two sliders set the radii of its
- * smallest and largest value, and a Linear, Log or Rank choice places values between them. Colour:
- * Colour by, which lists None, every layer that can colour (a levelled layer once per level) and
- * the rendered category and number columns; then for a layer or a category the palette, and for a
- * number the ramp, Linear or Log and Reverse, unless `hide-palettes` is set. A layer's palette is
- * the store's (`Store.setPalette`), whose size the clusters' slots are served for. While the
- * points are coloured by a category or a layer, Edit colours opens `<mosaica-colour-editor>` over
- * the page, listing the values or the clusters drawn (at the level coloured, on a levelled layer)
- * with their colours to choose and reset, in an order that holds through a pan or a filter. A field card's paint button chooses Colour by too. Density: how density is drawn, at what resolution, in which
- * colours and how strongly. Layers: the layer picker. The display settings are the explorer's properties of
- * the same names, passed to its map. `pinned-filters` names the columns whose cards are listed
- * before they hold a clause.
+ * A picked item's card opens beside its point and follows the point as the map moves. Picking
+ * another point replaces the card unless the viewer has pinned it.
  *
- * In a container narrower than 1000 px, either layout takes the overlay's form with a narrower card
- * of 264 px, every field card folded to one line until one is opened, and opening one folds the
- * one open before; the tools move to the bottom-left and the strip shortens its figures. In a
- * container 720 px wide or narrower, the heading sits in a bar above the map, the status strip
- * runs full width above a tab bar (Fields, Layers, Item), and each tab opens its panel as a sheet:
- * the filter panel, folded as in the compact form; the Layers popover's sections; and the item
- * card. The cards over the map are not drawn there.
+ * Each setting in the Layers popover is also an attribute of the explorer, so you can set it from
+ * HTML.
  *
- * Every event its elements fire bubbles out of it, since each is composed.
+ * Below 1000 px the explorer uses the overlay layout whatever `layout` says. At 720 px or less it
+ * opens its panels as sheets from a tab bar.
  *
- * @summary The map and every panel, in a default layout.
+ * @summary A complete map application in a single element.
  * @tagname mosaica-explorer
  * @category Elements
  * @slot toolbar - Replaces the view picker and the key picker.
@@ -209,9 +170,9 @@ const TABS = [
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-pick']>} mosaica-pick - A point was clicked.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-itemopen']>} mosaica-itemopen - The selected item's record arrived.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-basemapchange']>} mosaica-basemapchange - The map's basemap refusal or note changed.
- * @fires {CustomEvent<MosaicaEventDetails['mosaica-miss']>} mosaica-miss - A click on the map found nothing; the explorer closes the card that is not pinned and drops the selection.
+ * @fires {CustomEvent<MosaicaEventDetails['mosaica-miss']>} mosaica-miss - A click on the map found nothing. The explorer closes the unpinned card.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-hover']>} mosaica-hover - The pointer moved over a point.
- * @fires {CustomEvent<MosaicaEventDetails['mosaica-artifactopen']>} mosaica-artifactopen - An artifact was opened and its drill-down arrived.
+ * @fires {CustomEvent<MosaicaEventDetails['mosaica-artifactopen']>} mosaica-artifactopen - An artifact was opened and its details arrived.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-selectchange']>} mosaica-selectchange - A selection was drawn, changed or cleared, or its counts arrived.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-layerchange']>} mosaica-layerchange - The layers chosen changed.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-colourchange']>} mosaica-colourchange - Colour by changed, in the Layers popover or by a card's paint button.
@@ -231,7 +192,7 @@ const TABS = [
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-clausechange']>} mosaica-clausechange - A `member_of` clause was put on or taken off.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-artifactfit']>} mosaica-artifactfit - Fit was pressed on the artifact card; the explorer fits its map to the artifact.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-open']>} mosaica-open - Open was pressed on the item card.
- * @fires {CustomEvent<MosaicaEventDetails['mosaica-close']>} mosaica-close - A card's close button was pressed; the explorer closes the card and drops the selection it shows.
+ * @fires {CustomEvent<MosaicaEventDetails['mosaica-close']>} mosaica-close - A card's close button was pressed. The explorer closes the card and clears its selection.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-viewswitch']>} mosaica-viewswitch - The view changed through the view or key picker.
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-viewfollow']>} mosaica-viewfollow - A view chip on the item card was pressed; the explorer switches to that view and centres on the item.
  * @csspart frame - The explorer's grid.
@@ -276,8 +237,7 @@ const TABS = [
  * @csspart colour-option - An entry in the Colour by menu, with `data-value` (empty for None,
  *   `cluster:<layer>@<level>` for one level of a levelled layer) and `aria-checked`.
  * @csspart palette - The Palette button, while the points are coloured by a layer or a category.
- * @csspart palette-menu - The Palette menu, while it is open: a row per palette, each a strip of its
- *   colours, its name and a line saying how many it has.
+ * @csspart palette-menu - The Palette menu, while it is open.
  * @csspart palette-option - A palette in that menu, with `data-value` and `aria-checked`.
  * @csspart edit-colours - The Edit colours button, enabled while the points are coloured by a
  *   category or a layer.
@@ -289,16 +249,16 @@ const TABS = [
  * @csspart ramp-reverse - The Reverse button, with `aria-pressed`.
  * @csspart density-mode - The Density choice: None, Smooth, Hex, Grid and Lines, each with
  *   `data-mode` and `aria-checked`.
- * @csspart density-resolution - The Resolution slider, while density is drawn: the cell size on
- *   screen, coarse to fine. Its stops past the finest the server will count for the view are shown
- *   struck through, and the slider stops at the last one it can count.
+ * @csspart density-resolution - The Resolution slider for density's cell size, while density is
+ *   drawn. Sizes finer than the server allows for the view are struck through.
  * @csspart density-scale - The Linear and Log choice of density's colour scale, while density is
  *   drawn, each with `data-scale` and `aria-checked`.
  * @csspart density-colours - The button that opens the list of density colours, while density is
  *   drawn in colours.
  * @csspart density-strength - The Strength slider, while density is drawn.
- * @csspart detail - The item or artifact card in the map's top-right corner, where the map holds no
- *   position for the selection.
+ * @csspart detail - The item or artifact card in the map's top-right corner, used when the picked
+ *   item or artifact has no position on the map, such as after following an item into another
+ *   view.
  * @csspart sheet - The open sheet, in the narrow layout.
  * @csspart strip-row - The full-width status strip, in the narrow layout.
  * @csspart tabs - The tab bar, in the narrow layout.
@@ -1041,188 +1001,185 @@ let MosaicaExplorer = (() => {
         canBuildOwn = true;
         #layout_accessor_storage = __runInitializers(this, _layout_initializers, 'docked');
         /**
-         * `docked`, the map beside a sidebar, or `overlay`, the map full-bleed under a card holding the
-         * same panels.
+         * `docked` puts the panels in a sidebar beside the map. `overlay` makes the map fill the element
+         * and puts the panels in a card over it.
          */
         get layout() { return this.#layout_accessor_storage; }
         set layout(value) { this.#layout_accessor_storage = value; }
         #panels_accessor_storage = (__runInitializers(this, _layout_extraInitializers), __runInitializers(this, _panels_initializers, ALL_PANELS.join(' ')));
         /**
-         * Which regions appear, space- or comma-separated, from `toolbar` (the heading), `legend` (the
-         * Layers button and its popover), `filters` (the filter panel), `selection` and `detail` (the
-         * item and artifact cards). Defaults to all five. Any other name, such as `hierarchy`, shows
-         * nothing.
+         * The regions to show, separated by spaces or commas: `toolbar` (the heading), `legend` (the
+         * Layers button and popover), `filters` (the filter panel), `selection` (the selected region's
+         * card) and `detail` (the item and artifact cards). Defaults to all five. Other names are ignored.
          */
         get panels() { return this.#panels_accessor_storage; }
         set panels(value) { this.#panels_accessor_storage = value; }
         #colourBy_accessor_storage = (__runInitializers(this, _panels_extraInitializers), __runInitializers(this, _colourBy_initializers, ''));
-        /** Passed to the map's `colour-by`. */
+        /** What colours the points, as for `<mosaica-map>`'s `colour-by`. */
         get colourBy() { return this.#colourBy_accessor_storage; }
         set colourBy(value) { this.#colourBy_accessor_storage = value; }
         #layers_accessor_storage = (__runInitializers(this, _colourBy_extraInitializers), __runInitializers(this, _layers_initializers, ''));
-        /** Passed to the map's `layers`. */
+        /** The annotation layers to draw, as for `<mosaica-map>`'s `layers`. */
         get layers() { return this.#layers_accessor_storage; }
         set layers(value) { this.#layers_accessor_storage = value; }
         #tooltipFields_accessor_storage = (__runInitializers(this, _layers_extraInitializers), __runInitializers(this, _tooltipFields_initializers, ''));
-        /** Passed to the map's `tooltip-fields`. */
+        /** The columns the hover tooltip shows, as for `<mosaica-map>`'s `tooltip-fields`. */
         get tooltipFields() { return this.#tooltipFields_accessor_storage; }
         set tooltipFields(value) { this.#tooltipFields_accessor_storage = value; }
         #titleField_accessor_storage = (__runInitializers(this, _tooltipFields_extraInitializers), __runInitializers(this, _titleField_initializers, ''));
-        /** The field that titles a point, in the map's tooltip and the item card's headline. Unset, the title is the `mosaica_id`. */
+        /** The field that titles a point in the hover tooltip and the item card. Unset, the title is the `mosaica_id`. */
         get titleField() { return this.#titleField_accessor_storage; }
         set titleField(value) { this.#titleField_accessor_storage = value; }
         #subtitleField_accessor_storage = (__runInitializers(this, _titleField_extraInitializers), __runInitializers(this, _subtitleField_initializers, ''));
-        /** The field the item card shows under its headline. Unset, it shows none. */
+        /** The field the item card shows under its title. Unset, there is no subtitle. */
         get subtitleField() { return this.#subtitleField_accessor_storage; }
         set subtitleField(value) { this.#subtitleField_accessor_storage = value; }
         #cardFields_accessor_storage = (__runInitializers(this, _subtitleField_extraInitializers), __runInitializers(this, _cardFields_initializers, ''));
-        /** Passed to the item card's `card-fields`: the fields it shows before "Show all", in this order. Unset, the first three. */
+        /** The fields the item card shows before "Show all", in order, as for `<mosaica-item-card>`. Unset, the first three. */
         get cardFields() { return this.#cardFields_accessor_storage; }
         set cardFields(value) { this.#cardFields_accessor_storage = value; }
         #openUrl_accessor_storage = (__runInitializers(this, _cardFields_extraInitializers), __runInitializers(this, _openUrl_initializers, ''));
-        /** Passed to the item card's `open-url`: the address Open goes to, filled from the item's fields. Unset, and without `open`, there is no Open. */
+        /** The link template for the item card's Open button, as for `<mosaica-item-card>`. Without it or `open`, there is no Open button. */
         get openUrl() { return this.#openUrl_accessor_storage; }
         set openUrl(value) { this.#openUrl_accessor_storage = value; }
         #open_accessor_storage = (__runInitializers(this, _openUrl_extraInitializers), __runInitializers(this, _open_initializers, null));
-        /** Passed to the item card's `open`: called when Open is pressed. Set, it wins over `open-url`. */
+        /** A function the item card calls when Open is pressed, as for `<mosaica-item-card>`. Takes precedence over `open-url`. */
         get open() { return this.#open_accessor_storage; }
         set open(value) { this.#open_accessor_storage = value; }
         #budget_accessor_storage = (__runInitializers(this, _open_extraInitializers), __runInitializers(this, _budget_initializers, 0));
         /**
-         * How many marks to aim for on screen, passed to the map's `budget`. `0`, the default, leaves the
-         * store's own, which starts at 250000. Most points in the Layers popover sets the store's budget
-         * itself.
+         * How many marks to aim for on screen. `0` keeps the store's budget, which starts at 250000. Most
+         * points in the Layers popover changes the store's budget directly.
          */
         get budget() { return this.#budget_accessor_storage; }
         set budget(value) { this.#budget_accessor_storage = value; }
         #budgetMin_accessor_storage = (__runInitializers(this, _budget_extraInitializers), __runInitializers(this, _budgetMin_initializers, 1_000));
-        /** The fewest marks Most points offers, passed to the map's `budget-min`. */
+        /** The lowest value of the Most points slider. */
         get budgetMin() { return this.#budgetMin_accessor_storage; }
         set budgetMin(value) { this.#budgetMin_accessor_storage = value; }
         #budgetMax_accessor_storage = (__runInitializers(this, _budgetMin_extraInitializers), __runInitializers(this, _budgetMax_initializers, 2_000_000));
-        /** The most marks Most points offers, passed to the map's `budget-max`. */
+        /** The highest value of the Most points slider. */
         get budgetMax() { return this.#budgetMax_accessor_storage; }
         set budgetMax(value) { this.#budgetMax_accessor_storage = value; }
         #clusterBudget_accessor_storage = (__runInitializers(this, _budgetMax_extraInitializers), __runInitializers(this, _clusterBudget_initializers, 1_000));
         /**
-         * The most clusters a `nested` or `dag` layer is cut to, passed to the map's `cluster-budget`;
-         * `0` is the finest cut. Most clusters in the Layers popover sets the store's itself.
+         * The most clusters a `nested` or `dag` layer is cut to; `0` removes the limit. Most clusters in
+         * the Layers popover changes it.
          */
         get clusterBudget() { return this.#clusterBudget_accessor_storage; }
         set clusterBudget(value) { this.#clusterBudget_accessor_storage = value; }
         #clusterBudgetMin_accessor_storage = (__runInitializers(this, _clusterBudget_extraInitializers), __runInitializers(this, _clusterBudgetMin_initializers, 10));
-        /** The fewest clusters Most clusters offers. */
+        /** The lowest value of the Most clusters slider. */
         get clusterBudgetMin() { return this.#clusterBudgetMin_accessor_storage; }
         set clusterBudgetMin(value) { this.#clusterBudgetMin_accessor_storage = value; }
         #clusterBudgetMax_accessor_storage = (__runInitializers(this, _clusterBudgetMin_extraInitializers), __runInitializers(this, _clusterBudgetMax_initializers, 10_000));
-        /** The most clusters Most clusters offers. */
+        /** The highest value of the Most clusters slider. */
         get clusterBudgetMax() { return this.#clusterBudgetMax_accessor_storage; }
         set clusterBudgetMax(value) { this.#clusterBudgetMax_accessor_storage = value; }
         #basemap_accessor_storage = (__runInitializers(this, _clusterBudgetMax_extraInitializers), __runInitializers(this, _basemap_initializers, null));
         /**
-         * Passed to the map's `basemap`: `world`, `none`, `{tiles, attribution}`, `{image, bounds}`, a
-         * mapping from view id (as `meta.views` lists it, and not `tiles` or `image`) to one of those, or
-         * a deck.gl layer. The attribute takes `world` and `none`. Unset, the world outline under a view
-         * with a map projection and nothing under one without.
+         * What is drawn under the points, as for `<mosaica-map>`'s `basemap`. The attribute takes `world`
+         * and `none`. Unset, a view with a map projection gets the world outline and any other view gets
+         * nothing.
          */
         get basemap() { return this.#basemap_accessor_storage; }
         set basemap(value) { this.#basemap_accessor_storage = value; }
         #noPoints_accessor_storage = (__runInitializers(this, _basemap_extraInitializers), __runInitializers(this, _noPoints_initializers, false));
-        /** Passed to the map's `no-points`; the Points switch in the Layers popover changes it. */
+        /** Hides the points. The Points switch in the Layers popover changes it. */
         get noPoints() { return this.#noPoints_accessor_storage; }
         set noPoints(value) { this.#noPoints_accessor_storage = value; }
         #radius_accessor_storage = (__runInitializers(this, _noPoints_extraInitializers), __runInitializers(this, _radius_initializers, null));
-        /** Passed to the map's `radius`; the Size slider in the Layers popover changes it. */
+        /** A fixed point radius in pixels, as for `<mosaica-map>`. The Size slider in the Layers popover changes it. */
         get radius() { return this.#radius_accessor_storage; }
         set radius(value) { this.#radius_accessor_storage = value; }
         #sizeBy_accessor_storage = (__runInitializers(this, _radius_extraInitializers), __runInitializers(this, _sizeBy_initializers, ''));
-        /** Passed to the map's `size-by`; the Size by choice in the Layers popover changes it. */
+        /** The number column that sizes the points, as for `<mosaica-map>`. Size by in the Layers popover changes it. */
         get sizeBy() { return this.#sizeBy_accessor_storage; }
         set sizeBy(value) { this.#sizeBy_accessor_storage = value; }
         #sizeMin_accessor_storage = (__runInitializers(this, _sizeBy_extraInitializers), __runInitializers(this, _sizeMin_initializers, null));
-        /** Passed to the map's `size-min`; the smallest-size slider in the Layers popover changes it. */
+        /** The radius of the smallest value under `size-by`. A slider in the Layers popover changes it. */
         get sizeMin() { return this.#sizeMin_accessor_storage; }
         set sizeMin(value) { this.#sizeMin_accessor_storage = value; }
         #sizeMax_accessor_storage = (__runInitializers(this, _sizeMin_extraInitializers), __runInitializers(this, _sizeMax_initializers, null));
-        /** Passed to the map's `size-max`; the largest-size slider in the Layers popover changes it. */
+        /** The radius of the largest value under `size-by`. A slider in the Layers popover changes it. */
         get sizeMax() { return this.#sizeMax_accessor_storage; }
         set sizeMax(value) { this.#sizeMax_accessor_storage = value; }
         #sizeScale_accessor_storage = (__runInitializers(this, _sizeMax_extraInitializers), __runInitializers(this, _sizeScale_initializers, ''));
-        /** Passed to the map's `size-scale`; the Scale choice in the Layers popover changes it. */
+        /** How values are placed between the two sizes, as for `<mosaica-map>`. The Scale choice in the Layers popover changes it. */
         get sizeScale() { return this.#sizeScale_accessor_storage; }
         set sizeScale(value) { this.#sizeScale_accessor_storage = value; }
         #hideSize_accessor_storage = (__runInitializers(this, _sizeScale_extraInitializers), __runInitializers(this, _hideSize_initializers, false));
-        /** Leaves the Size slider out of the Layers popover, for a host that sets `radius` itself. */
+        /** Leaves the Size slider out of the Layers popover, for when you set `radius` yourself. */
         get hideSize() { return this.#hideSize_accessor_storage; }
         set hideSize(value) { this.#hideSize_accessor_storage = value; }
         #pointOpacity_accessor_storage = (__runInitializers(this, _hideSize_extraInitializers), __runInitializers(this, _pointOpacity_initializers, null));
-        /** Passed to the map's `point-opacity`; the Opacity slider in the Layers popover changes it. */
+        /** A fixed point opacity from 0.1 to 1. The Opacity slider in the Layers popover changes it. */
         get pointOpacity() { return this.#pointOpacity_accessor_storage; }
         set pointOpacity(value) { this.#pointOpacity_accessor_storage = value; }
         #density_accessor_storage = (__runInitializers(this, _pointOpacity_extraInitializers), __runInitializers(this, _density_initializers, 'none'));
-        /** Passed to the map's `density`; the Density choice in the Layers popover changes it. */
+        /** How density is drawn, as for `<mosaica-map>`. The Density choice in the Layers popover changes it. */
         get density() { return this.#density_accessor_storage; }
         set density(value) { this.#density_accessor_storage = value; }
         #densityColours_accessor_storage = (__runInitializers(this, _density_extraInitializers), __runInitializers(this, _densityColours_initializers, ''));
-        /** Passed to the map's `density-colours`; the Colours choice in the Layers popover changes it. */
+        /** The colours density is drawn in, as for `<mosaica-map>`. The Colours choice in the Layers popover changes it. */
         get densityColours() { return this.#densityColours_accessor_storage; }
         set densityColours(value) { this.#densityColours_accessor_storage = value; }
         #densityStrength_accessor_storage = (__runInitializers(this, _densityColours_extraInitializers), __runInitializers(this, _densityStrength_initializers, 1));
-        /** Passed to the map's `density-strength`; the Strength slider in the Layers popover changes it. */
+        /** How strongly density is drawn, from 0.1 to 1. The Strength slider in the Layers popover changes it. */
         get densityStrength() { return this.#densityStrength_accessor_storage; }
         set densityStrength(value) { this.#densityStrength_accessor_storage = value; }
         #densityResolution_accessor_storage = (__runInitializers(this, _densityStrength_extraInitializers), __runInitializers(this, _densityResolution_initializers, DEFAULT_DENSITY_CELL_PX));
         /**
-         * Passed to the map's `density-resolution`, the cell size on screen in CSS pixels; the Resolution
+         * The size of density's cells on screen, in CSS pixels, as for `<mosaica-map>`. The Resolution
          * slider in the Layers popover changes it.
          */
         get densityResolution() { return this.#densityResolution_accessor_storage; }
         set densityResolution(value) { this.#densityResolution_accessor_storage = value; }
         #densityScale_accessor_storage = (__runInitializers(this, _densityResolution_extraInitializers), __runInitializers(this, _densityScale_initializers, DEFAULT_DENSITY_SCALE));
-        /** Passed to the map's `density-scale`; the Scale choice under Resolution in the Layers popover changes it. */
+        /** `linear` or `log` colouring of density counts. The Scale choice under Resolution in the Layers popover changes it. */
         get densityScale() { return this.#densityScale_accessor_storage; }
         set densityScale(value) { this.#densityScale_accessor_storage = value; }
         #palette_accessor_storage = (__runInitializers(this, _densityScale_extraInitializers), __runInitializers(this, _palette_initializers, ''));
         /**
-         * Passed to the map's `palette`, the palette a layer's clusters are coloured from; the Palette
-         * choice in the Colour section changes it while the points are coloured by a layer.
+         * The palette clusters are coloured from, as for `<mosaica-map>`. The Palette choice in the Colour
+         * section changes it while the points are coloured by a layer.
          */
         get palette() { return this.#palette_accessor_storage; }
         set palette(value) { this.#palette_accessor_storage = value; }
         #categoryPalette_accessor_storage = (__runInitializers(this, _palette_extraInitializers), __runInitializers(this, _categoryPalette_initializers, ''));
-        /** Passed to the map's `category-palette`. */
+        /** The palette for colouring by a category column, as for `<mosaica-map>`. */
         get categoryPalette() { return this.#categoryPalette_accessor_storage; }
         set categoryPalette(value) { this.#categoryPalette_accessor_storage = value; }
         #ramp_accessor_storage = (__runInitializers(this, _categoryPalette_extraInitializers), __runInitializers(this, _ramp_initializers, ''));
-        /** Passed to the map's `ramp`. */
+        /** The colour ramp for colouring by a number column, as for `<mosaica-map>`. */
         get ramp() { return this.#ramp_accessor_storage; }
         set ramp(value) { this.#ramp_accessor_storage = value; }
         #rampScale_accessor_storage = (__runInitializers(this, _ramp_extraInitializers), __runInitializers(this, _rampScale_initializers, ''));
-        /** Passed to the map's `ramp-scale`. */
+        /** How numbers are placed on the ramp, `linear` or `log`. */
         get rampScale() { return this.#rampScale_accessor_storage; }
         set rampScale(value) { this.#rampScale_accessor_storage = value; }
         #rampReverse_accessor_storage = (__runInitializers(this, _rampScale_extraInitializers), __runInitializers(this, _rampReverse_initializers, false));
-        /** Passed to the map's `ramp-reverse`. */
+        /** Runs the ramp from its high end to its low end. */
         get rampReverse() { return this.#rampReverse_accessor_storage; }
         set rampReverse(value) { this.#rampReverse_accessor_storage = value; }
         #valueColours_accessor_storage = (__runInitializers(this, _rampReverse_extraInitializers), __runInitializers(this, _valueColours_initializers, null));
-        /** Passed to the map's `valueColours`. */
+        /** Colours for individual category values, as for `<mosaica-map>`'s `valueColours`. */
         get valueColours() { return this.#valueColours_accessor_storage; }
         set valueColours(value) { this.#valueColours_accessor_storage = value; }
         #clusterColours_accessor_storage = (__runInitializers(this, _valueColours_extraInitializers), __runInitializers(this, _clusterColours_initializers, null));
-        /** Passed to the map's `clusterColours`. */
+        /** Colours for individual clusters, as for `<mosaica-map>`'s `clusterColours`. */
         get clusterColours() { return this.#clusterColours_accessor_storage; }
         set clusterColours(value) { this.#clusterColours_accessor_storage = value; }
         #datasetTitle_accessor_storage = (__runInitializers(this, _clusterColours_extraInitializers), __runInitializers(this, _datasetTitle_initializers, ''));
-        /** The dataset's title, which heads the explorer above the view's name. Unset, the view's name is the heading. */
+        /** The dataset's title, shown as the heading above the view's name. Unset, the view's name is the heading. */
         get datasetTitle() { return this.#datasetTitle_accessor_storage; }
         set datasetTitle(value) { this.#datasetTitle_accessor_storage = value; }
         #pinnedFilters_accessor_storage = (__runInitializers(this, _datasetTitle_extraInitializers), __runInitializers(this, _pinnedFilters_initializers, ''));
-        /** Passed to the filter panel's `pinned`: the columns whose cards are listed before they hold a clause. */
+        /** Columns whose field cards always show, even when they hold no filter, as for `<mosaica-filter-panel>`'s `pinned`. */
         get pinnedFilters() { return this.#pinnedFilters_accessor_storage; }
         set pinnedFilters(value) { this.#pinnedFilters_accessor_storage = value; }
         #hidePalettes_accessor_storage = (__runInitializers(this, _pinnedFilters_extraInitializers), __runInitializers(this, _hidePalettes_initializers, false));
-        /** Leaves the palette and ramp choices out of the Colour section, for a host that sets them. */
+        /** Leaves the palette and ramp choices out of the Colour section, for when you set them yourself. */
         get hidePalettes() { return this.#hidePalettes_accessor_storage; }
         set hidePalettes(value) { this.#hidePalettes_accessor_storage = value; }
         #menu_accessor_storage = (__runInitializers(this, _hidePalettes_extraInitializers), __runInitializers(this, _menu_initializers, null));
@@ -1369,7 +1326,7 @@ let MosaicaExplorer = (() => {
             this.map?.dispose();
             super.dispose();
         }
-        /** The `<mosaica-map>` the explorer renders, for a host that calls `fit`, `fitTo` or `select`. */
+        /** The explorer's `<mosaica-map>`, for calling its methods such as `fit`, `fitTo` or `select`. */
         get map() {
             return this.renderRoot?.querySelector('mosaica-map') ?? null;
         }
@@ -1500,8 +1457,6 @@ let MosaicaExplorer = (() => {
           tooltip-fields=${this.tooltipFields}
           title-field=${this.titleField || nothing}
           budget=${this.budget || nothing}
-          .budgetMin=${this.budgetMin}
-          .budgetMax=${this.budgetMax}
           .clusterBudget=${this.clusterBudget}
           controls-corner=${compact ? 'bottom-left' : 'top-left'}
           .clusterLevel=${level}

package/dist/field-card.d.ts

@@ -10,59 +10,27 @@ type Brush = {
     open: boolean;
 };
 /**
- * One field as a card in the filter panel: a category's commonest values, a layer's largest
- * clusters, a number's or a date's histogram, or a text field's search box, under the field's name.
- * `field` is a column `meta.filterOperands` lists, or `cluster:<layer>` for a layer whose clusters
- * can be filtered by.
+ * Use a field card on its own when you want one field's chart in a place of your choosing.
+ * `<mosaica-filter-panel>` shows one for each field. Set `field` to a column `meta.filterOperands`
+ * lists, or to `cluster:<layer>` for a layer's clusters.
  *
- * The counts are taken over two sets. The subject is what is in view: the items in the camera's box
- * that the filters admit, or the highlighted ones while a highlight is set. The whole match is every
- * item the filters admit. Both leave out the card's own clause in the filter position, so a value
- * its clause excludes keeps its count. The card keeps three aggregates registered with the store
- * while it is drawn (`Store.setAggregate`): the subject's counts (`subject: 'view'` with
- * `highlighted`), the whole match's, and for a number or a date its figures over everything the
- * viewer may see (`subject: 'visible'`). A folded card asks for the subject's alone.
+ * The solid bars count the items in view that the filters match, or the highlighted items while
+ * there is a highlight. The pale bars count every item the filters match. Neither count applies the
+ * card's own filter, so a value the viewer has filtered out keeps its count.
  *
- * A category or cluster card lists five values, those with most items in the subject first and any
- * its own clauses name, with "N more" opening it to twenty. Each row has its name (a cluster's
- * parents in grey after it), a solid bar for its share of the subject and a pale bar for its share
- * of the whole match, each a share of its own total, and the two counts. Under a filter on the
- * field, the values it leaves out are greyed and show only how many items they would add, and the
- * shares are of what the filter keeps. Hovering or focusing a row shows Highlight and Filter, which
- * put the value in or out of the field's clause in that position. A click or tap on the row does
- * what its Filter button does and shows its buttons; the row takes no focus, and the keyboard
- * reaches the buttons. Over the rows is the field's search box, the typeahead of
- * `<mosaica-filter>` or `<mosaica-cluster-filter>`, whose choice joins the filter. A levelled
- * layer's card has a Level choice in its heading, the top (coarsest) level by default, which fires
- * `mosaica-levelchange`. A cluster card ranks a `nested` or `dag` layer's clusters at the cut the
- * map draws (`cut: 'drawn'`), and a flat or levelled layer's at its level.
- * A cluster is named as the aggregate's table names it, which is the name the layer's browse pages
- * give the same viewer. On a `nested` or `dag` layer its path is named from a browse page of its
- * parents and one of its first parent's.
+ * What the card shows depends on the kind of field:
  *
- * A number or date card draws about twenty bins over the values the viewer may see, the pale bar
- * the whole match and the solid one the subject, each bin's height its share of its own set, scaled
- * so the tallest share fills the plot. The counts are taken from a sample of about 100,000 items
- * where a set is larger, and an estimate is marked "≈". Dragging across the bins, or the arrow keys
- * with Shift on the focused plot and then Enter, opens a box naming the range and how many items
- * match in it, with Filter and Highlight, which set the field's range in that position. A range set
- * on the field is outlined on the plot. The heading gives the field's figures: how many items hold
- * a value and their mean, or their range while folded.
+ * - A category or cluster card lists the values with most items in view, each with Highlight and
+ *   Filter buttons.
+ * - A number or date card draws a histogram, and the viewer drags across it to pick a range to
+ *   filter or highlight by. From the keyboard, they press Shift and the arrow keys on the focused
+ *   plot, then Enter. Counts over about 100,000 items come from a sample, so they are marked "≈".
+ * - A text or keyword field's card is a search box, `<mosaica-filter>`.
  *
- * A text or keyword field is its `<mosaica-filter>` search box.
+ * While the paint button colours the map by the field, clicking a value's colour opens a picker
+ * that changes the colour on the map.
  *
- * The paint button colours the map by the field, or by nothing where it already does
- * (`Store.setColourBy`), and is pressed while it does. Then a category or cluster card shows each
- * value's colour beside it, and a number or date card the ramp under its plot. Each colour is a
- * button that opens a colour picker: the palette's colours and a lighter row, a custom area with a
- * hue bar and a hex field, and Reset, which gives the value or the cluster its palette colour back.
- * A choice applies at once and fires `mosaica-valuecolour` for a category value, written to the
- * colour choices every element over the store shares, or `mosaica-clustercolour` for a cluster,
- * set on the store with its other chosen colours (`Store.setArtifactColours`).
- *
- * `folded` draws the heading alone, with a small chart of the subject's counts.
- *
- * @summary One field's counts in view and overall, with its filter and highlight.
+ * @summary A card that charts one field's values and filters or highlights by them.
  * @tagname mosaica-field-card
  * @category Elements
  * @fires {CustomEvent<MosaicaEventDetails['mosaica-filterchange']>} mosaica-filterchange - A row's
@@ -87,11 +55,11 @@ type Brush = {
  * @csspart paint - The paint button, with `aria-pressed`.
  * @csspart fold - The fold button, with `aria-expanded`.
  * @csspart rows - A category or cluster card's rows.
- * @csspart row - One row, with `data-key` and `data-state`: `in` for a value the field's filter
- *   keeps, `out` for one it leaves out, `lit` for one its highlight lights, else empty.
- * @csspart swatch - A row's colour, while the map is coloured by the field, a button that opens the
- *   colour picker, with `data-unmet` and drawn as an outline for a category value the map has not
- *   drawn yet and so has given no colour.
+ * @csspart row - One row, with `data-key` and `data-state`: `in` if the field's filter keeps the
+ *   value, `out` if it leaves it out, `lit` if it is highlighted, otherwise empty.
+ * @csspart swatch - A row's colour button, while the map is coloured by the field. It opens the
+ *   colour picker. It carries `data-unmet`, and is drawn as an outline, for a value the map has not
+ *   drawn yet and so has not given a colour.
  * @csspart name - A row's name, with `data-unnamed` for a cluster that has none.
  * @csspart path - A cluster row's parents.
  * @csspart bar-match - A row's or a bin's pale bar, its share of the whole match.
@@ -123,11 +91,11 @@ export declare class MosaicaFieldCard extends MosaicaElement {
     static styles: import("lit").CSSResult[];
     /** The field: a column `meta.filterOperands` lists, or `cluster:<layer>` for a layer's clusters. */
     accessor field: string;
-    /** Draws the heading alone, with a small chart of the subject's counts. */
+    /** Shows the heading alone, with a small chart of the counts in view. */
     accessor folded: boolean;
-    /** Draws the small chart for the compact layout. */
+    /** Draws a folded card in the compact style the explorer uses in narrow containers. */
     accessor compact: boolean;
-    /** The level a levelled layer's card counts at; `null` is its top level. */
+    /** The level a card for a layer with levels counts at. `null` is the coarsest level. */
     accessor level: number | null;
     /** Whether "N more" was pressed. @internal */
     accessor expanded: boolean;