@vernikr/size-report 2.7.0 → 2.8.1

package/src/table.css

@@ -1,70 +1,116 @@
-/* One type face for the whole table; numbers line up by their digits thanks to tabular-nums rather than through a
- * monospaced font.
+/* The report's table: a grid of plain elements rather than a `<table>`, and only the part of it the reader looks at is
+ * built (`src/page/table.js` says why, and what was measured).
  *
- * The layout is **fixed**, and the widths come from the `<colgroup>` the page builds along with the table (`appCols`):
- * laying this table out as `auto` means measuring every cell of it — 174 468 of them here — to assign the widths of
- * 265 columns.
+ * Everything here hangs off `#grid`, and that is not a habit: this sheet is the package's **shared** part (`src/css.js`)
+ * while the page brings a `.panel .row` of its own, and an unscoped rule for the table's rows took that row out of the
+ * flow with it (the panel's switches stood on top of one another until the rules were scoped).
  *
- * **Both declarations are needed, and the width is the one that is easy to lose.** A fixed layout with `width: auto`
- * falls back to the automatic algorithm — the specification says so, and Chrome does it: the columns' widths are then
- * ignored, the cells are measured all the same, and nothing looks wrong except that nothing is won. `100%` is what
- * gives the table a definite width: it is the window, and the columns are wider than it, so the table keeps the widths
- * it was given (`check` and the browser probe both watch this). */
-table { border-collapse: collapse; font-variant-numeric: tabular-nums; table-layout: fixed; width: 100%; }
-/* A counted width is the **border box** of a column — the padding of its cells and the group's border are inside it
- * (measured in Chrome: `7ch` gave a 47px content box with 4px of padding each side). `--ch` is that count in
- * characters, written by the page per column; `--clip` is the fixed measure a commit's caption is clipped to, and the
- * one a narrow window may shorten (app.css). */
-#grid { --cell-pad: 4px; --col-line: 1px; --clip: 190px; }
-th, td { padding: 2px var(--cell-pad); border-bottom: 1px solid rgba(127, 127, 127, .25); white-space: nowrap; }
-/* The count over-measures a sign and a thin space, which is the safe side: a cell clips nothing, so a column a
- * character short would show a number running over its neighbour. */
-#grid col { width: calc(var(--ch, 0px) + var(--cell-pad) * 2 + var(--col-line)); }
-#grid col.c-commit { width: calc(var(--clip) + var(--cell-pad) * 2 + var(--col-line)); }
-/* A two-row header: both rows stick, so the second is offset by exactly the first one's height (line-height 20 plus the
- * 2px bottom border), or the rows would overlap. */
-thead th { position: sticky; top: 0; z-index: 3; background: Canvas; text-align: center; line-height: 20px; padding: 0 var(--cell-pad); }
-thead tr:first-child th { border-bottom-width: 2px; }
-thead tr:last-child th { top: 22px; }
-.num { text-align: right; }
-/* The group's left border is carried by the first *enabled* metric: four rules instead of the eight combinations of
- * "which of them is first", so switching a metric off moves the border by itself and no line of JS knows about it.
- * The registry holds four metrics (`raw`, `min`, `tok`, `gzip`) — that is the count below, and `test/page-view.test.js`
- * reddens if a fifth name appears. A group's heading (`.gh`) spans its metrics rather than belonging to one, so its
- * own left edge is there while any metric is on (`.m-none` is set when the reader switched them all off). */
-#grid .g { border-left: 0; }
-#grid:not(.m-off-0) .g.m0,
-#grid.m-off-0:not(.m-off-1) .g.m1,
-#grid.m-off-0.m-off-1:not(.m-off-2) .g.m2,
-#grid.m-off-0.m-off-1.m-off-2:not(.m-off-3) .g.m3 { border-left: 1px solid rgba(127, 127, 127, .35); }
-#grid:not(.m-none) .gh { border-left: 1px solid rgba(127, 127, 127, .35); }
-/* A metric switched off hides all of its cells and both of its headings at once — one class on the table instead of a
- * pass over the metric's cells (measured: 265 operations against 56 496). */
-#grid.m-off-0 .m0, #grid.m-off-1 .m1, #grid.m-off-2 .m2, #grid.m-off-3 .m3 { display: none; }
-/* A file's column switched off: its cells and its headings together. The hidden column keeps its place in the markup,
- * so the columns that stay do not move. */
-#grid .off { display: none; }
-/* The sticky left column: an opaque background (Canvas), or numbers would show through the cell when scrolling sideways. A
- * tier above the neighbouring cells (2) and below the header (3); the header's corner is above them all, or the column groups
- * would crawl over the commit column. */
-.c-commit { position: sticky; left: 0; z-index: 2; background: Canvas; text-align: left; font-weight: 400; }
-.c-commit a { color: inherit; }
-thead .c-commit { z-index: 6; }
-/* This block fills the commit column, whose width is set by the column itself (`#grid col.c-commit`). It took the
- * column's measure with it: the cell's content would otherwise go past its borders and be drawn over the neighbouring
- * numbers, because a table cell clips nothing. */
-.clip { display: flex; align-items: baseline; gap: 6px; width: 100%; }
-.when { flex: none; opacity: .7; }
-.subj { flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; display: block; }
-.subj.plain { opacity: .7; }
-.sect { flex: none; opacity: .7; font-size: 11px; text-decoration: none; border-bottom: 1px dotted currentColor; }
+ * Four figures are the whole geometry — a metric column, a row, the header and the commit column — and they are written
+ * twice, here and in the script that counts the window's ordinals in them. Two copies of a number are two answers waiting
+ * to happen, hence `test/page-grid.test.js` reads these four declarations and holds the script to them.
+ *
+ * One border: 1px of one colour — a row's bottom edge, a group's left edge, the lines of the header. A heavier line or a
+ * second colour would promise a hierarchy to be worked out rather than read.
+ *
+ * One type face for the whole table; numbers line up by their digits thanks to tabular-nums rather than through a
+ * monospaced font. Every column is the same width and fixed: the numbers are short and of one kind, and a width that came
+ * out of the text would have to be measured over every cell of the column — the very cost this step removed. The header is
+ * two lines of one row each — `--head` is exactly two `--row` — and a name too long for its group is cut with an ellipsis
+ * rather than wrapped (`appCaption`) or run over its neighbour.
+ */
+#grid {
+  --col: 70px;
+  --row: 25px;
+  --head: 50px;
+  --commit: 220px;
+  --grid-line: rgba(127, 127, 127, .25);
+  position: relative;
+  font-variant-numeric: tabular-nums;
+}
+
+/* The window: the rows stand at their own `top` inside the scrolled content, so scrolling costs the browser nothing but
+ * painting — no layout and no script — while the width of the content gives the scrollbar its length and the script its
+ * ordinals. The cells of a row are one grid of fixed tracks (`grid-auto-columns`): a cell cannot change the width of a
+ * column, and it cannot push its neighbour. */
+#grid .row { position: absolute; left: 0; width: 100%; height: var(--row); }
+#grid .cells {
+  position: absolute;
+  top: 0;
+  display: grid;
+  grid-auto-flow: column;
+  grid-auto-columns: var(--col);
+  height: var(--row);
+}
+#grid .cells > span, #grid .hgroups > span, #grid .hmetrics > span { box-sizing: border-box; white-space: nowrap; }
+/* Two pixels of padding and a line of twenty: with the border, a cell is one `--row` high — the same for the header's
+ * cells as for the numbers, or the header would be a band of another rhythm. */
+#grid .cells > span {
+  padding: 2px 4px;
+  line-height: 20px;
+  border-bottom: 1px solid var(--grid-line);
+}
+#grid .num { text-align: right; }
+/* The left edge of a group — the total, and every file — is carried by the group's first metric. One class instead of
+ * the four rules of "which metric is switched on": the window is built out of the files that are on, so which column
+ * stands first in a group is the page's own answer rather than something the styling has to work out. */
+#grid .cells > .g, #grid .hmetrics > .g, #grid .hgroups > .gh { border-left: 1px solid var(--grid-line); }
+
+/* The header: one row of groups (the total and the files) over one row of metrics, stuck to the top edge of the shell,
+ * and the commit column stuck to its left edge. Both carry an opaque background (Canvas), or the numbers would show
+ * through them while the reader scrolls. The two lines are placed by `top` and are one row high each, so the header
+ * aligns with the table below it rather than standing a size of its own. */
+#grid .head { position: sticky; top: 0; left: 0; z-index: 3; height: var(--head); background: Canvas; }
+#grid .hgroups, #grid .hmetrics { position: absolute; display: grid; grid-auto-flow: column; grid-auto-columns: var(--col); }
+#grid .hgroups { top: 0; height: var(--row); }
+#grid .hmetrics { top: var(--row); height: var(--row); }
+#grid .hgroups > span, #grid .hmetrics > span {
+  padding: 2px 4px;
+  line-height: 20px;
+  border-bottom: 1px solid var(--grid-line);
+}
+/* A file's name stands over its group of metrics and is centred on it: the group is a column of numbers, and a caption
+ * that began at its left edge would carry the eye to the wrong place. */
+#grid .hgroups > span { text-align: center; overflow: hidden; text-overflow: ellipsis; }
+#grid .hmetrics > span { text-align: center; color: CanvasText; }
+
+/* The commit column: a sticky cell of every row, so the commit a number belongs to is in sight while the reader scrolls
+ * sideways. Its width is fixed and is the script's `APP_COMMIT` as well — the numbers are placed from the left edge of
+ * the grid *beside* the column, and a caption longer than it is clipped (the whole subject stands in the tooltip). */
+#grid .c-commit {
+  position: sticky;
+  left: 0;
+  z-index: 2;
+  box-sizing: border-box;
+  width: var(--commit);
+  height: var(--row);
+  line-height: var(--row);
+  padding: 0 4px;
+  background: Canvas;
+  text-align: left;
+  font-weight: 400;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+  border-bottom: 1px solid var(--grid-line);
+}
+#grid .c-commit a { color: inherit; }
+#grid .head .c-commit { z-index: 6; height: var(--head); line-height: var(--head); }
+/* This block fills the commit column: the cell clips what does not fit, and the subject is what gives way (the flex
+ * item of `flex: 1 1 auto`), while the date and the journal mark keep their own width. */
+#grid .clip { display: flex; align-items: baseline; gap: 6px; width: 100%; }
+#grid .when { flex: none; opacity: .7; }
+#grid .subj { flex: 1 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; display: block; }
+#grid .subj.plain { opacity: .7; }
+#grid .sect { flex: none; opacity: .7; font-size: 11px; text-decoration: none; border-bottom: 1px dotted currentColor; }
 /* Growth green, fall red — by agreement with whoever asked for the report (growth is "more logic" rather than alarm). */
-.up { color: #1e8449; }
-.down { color: #c0392b; }
-.miss { opacity: .5; }
-/* The top row holds the current sizes: it is also what explains what the deltas refer to. */
-tr.now th, tr.now td { border-bottom: 2px solid rgba(127, 127, 127, .35); }
-tr.now .c-commit { font-weight: 600; }
-/* A row's highlight is laid over rather than swapped in: the sticky column has to stay opaque, or numbers show through it
- * when scrolling. */
-tbody tr:hover th, tbody tr:hover td { background-image: linear-gradient(rgba(127, 127, 127, .08), rgba(127, 127, 127, .08)); }
+#grid .up { color: #1e8449; }
+#grid .down { color: #c0392b; }
+#grid .miss { opacity: .5; }
+/* The top row holds the current sizes: it is also what explains what the deltas below refer to — by its weight rather
+ * than by a heavier line, which would be a second border among the rows. */
+#grid .row.now > .c-commit { font-weight: 600; }
+/* A row's highlight is laid over rather than swapped in: the sticky column has to stay opaque, or numbers show through
+ * it while the reader scrolls sideways. */
+#grid .row:hover > .c-commit, #grid .row:hover > .cells > span {
+  background-image: linear-gradient(rgba(127, 127, 127, .08), rgba(127, 127, 127, .08));
+}

package/src/page/work.js

@@ -1,55 +0,0 @@
-/* The page's long work, and the stripe that says it is going on.
- *
- * A switch on a file's box changes a class on every node of that file's column, and a folder or a category is that same
- * work over every file below it. That alone is cheap — measured at about 2 µs a node, so a whole category of this
- * repository's report (73 columns, 55 042 nodes) is 120 ms of it — but it is not the price. **The browser lays this
- * table out again for any change of a column's visibility, and that is close to a second on a table of a few hundred
- * thousand cells** (`probes/step-12-columns.mjs`: 1 cell toggled 234 ms of layout, 750 cells 287 ms, 6 000 cells
- * 539 ms, and the whole click on the shipped page 867 ms blocked with a 742 ms task).
- *
- * Hence the shape of this chapter, and it is a decision rather than a default. The drawing of a switch is **one task**:
- * what is queued is drawn in a single go, one layout, one repaint. Slicing it — a queue worked off between timeouts —
- * was written first and measured (Chrome 153, this repository's report): 37 slices of two columns each paid the table's
- * relayout 37 times, 2.5–4 s a slice, 95 frames and 169 layouts of 151.9 s of pure layout time against 1.04 s for the
- * same click when it is not sliced, with the tab growing to several gigabytes of repaint. The slice is the thing that
- * freezes the page, only more often, so there is none.
- *
- * What is left is honesty about it: work short enough to be over before the browser could paint a stripe is done on the
- * click itself, and above that the stripe appears, the drawing happens in the next task, and the stripe goes away —
- * so a reader sees that the page is working rather than wondering whether it hung. The stripe carries no share: within
- * one task the browser cannot repaint, so a bar that filled would be a bar that lies, and the page already knows the
- * one thing that is true about it (the work is going on).
- */
-
-/* Above this much node work the drawing is one task with a stripe rather than a task on the click: a stripe that
- * appears and disappears within the same frame is worse than none, and the figure is one file's column of a report of
- * this repository's size (754 nodes). */
-export const APP_LONG = 2000;
-
-/* The stripe: on while a switch is being drawn, off when it is done. There is nothing to count here, and the length is
- * carried by the styling (an indeterminate stripe), which is why this function takes a switch rather than a share. */
-export function appBar(shown) {
-  const bar = document.getElementById('bar');
-  if (bar !== null) bar.hidden = !shown;
-}
-
-/* What a switch asks for: `items` are the columns that have to be drawn (`{i, units}` — the file's index and the nodes
- * of its column), `step` draws one of them from the view, and the total decides whether the drawing is the reader's own
- * click or the next task with the stripe over it. Only the columns out of step with the view are asked for at all
- * (`appColumnStale`), so a report opened with everything switched on has nothing to draw here. */
-export function appDraw(step, items) {
-  /* Counted by a plain walk rather than by `reduce`: the page's shell is held to a rule that it counts no totals of the
-   * table itself, and a guard that has to tell a sum of nodes from a sum of numbers is a guard that will be argued with
-   * one day. The count of nodes is not one of the report's numbers. */
-  let units = 0;
-  items.forEach((item) => { units += item.units; });
-  if (units <= APP_LONG) {
-    items.forEach((item) => step(item.i));
-    return;
-  }
-  appBar(true);
-  setTimeout(() => {
-    items.forEach((item) => step(item.i));
-    appBar(false);
-  }, 0);
-}