@inflexa-ai/harness 0.20.0 → 0.21.1

package/dist/report-render/page.d.ts

@@ -1,15 +1,27 @@
 /**
- * The page constants: the head references, the readiness names, and the two page-side scripts.
+ * The page constants: the head references, the readiness names, and the page-side scripts.
  *
  * A script here is browser source text, not module code. Thus it reads no module binding, and each value
- * that it needs is interpolated at build time. The style rules and the ECharts theme live in `design.ts`.
+ * that it needs is interpolated at build time. The style rules, the ECharts theme, and the grid theme
+ * parameters live in `design.ts`.
  */
 /**
- * The head references of the staged assets. The page loads the chart runtime from the sibling assets
- * directory, thus the head names no remote host. The manifest gives the staged name, thus the tag and the
- * stage step of the caller cannot disagree.
+ * The head reference of the chart runtime. The page loads it from the sibling assets directory, thus the
+ * head names no remote host. The manifest gives the staged name, thus the tag and the stage step of the
+ * caller cannot disagree.
+ *
+ * The tag is a classic script. A `file://` page refuses a module request, thus a classic script is the one
+ * form that loads beside the page.
  */
 export declare const ASSET_HEAD: string;
+/**
+ * The head reference of the grid runtime.
+ *
+ * The bundle weighs about two megabytes, and a page with no table has nothing to build. Thus the skeleton
+ * writes this tag only for a page that carries table data, and the manifest still stages the file for the
+ * whole directory.
+ */
+export declare const GRID_ASSET_HEAD: string;
 /**
  * The name of the readiness event, and the name of the window sentinel that guards a late listener. The
  * bootstrap below emits both names, thus this module owns them. A capture that waits for the page reads the
@@ -24,12 +36,32 @@ export declare const THEME_READY_SENTINEL = "__inflexaThemeReady";
  */
 export declare const PAGE_NAV_TIMEOUT_MS = 20000;
 export declare const PAGE_READY_TIMEOUT_MS = 8000;
+/**
+ * The client twin of the chart data derivation, as browser source text.
+ *
+ * A dense chart ships no row. Its option states, for each series, the columns of the payload that it reads,
+ * the transform of each column, the split that it holds, and the rows that carry a point label. This
+ * fragment reads those descriptors and builds the data of each series.
+ *
+ * The fragment writes its own constants, because a page script reads no module binding. Each rule here is
+ * the twin of one rule of the server derivation: the number read of a cell, the four transforms, the
+ * competition rank, the compare of a sort, and the three-way classification of a preset. A shared test
+ * vector runs the transforms of both sides over one set of cells, thus the two cannot drift in silence.
+ *
+ * The build reads the decoded rows of the payload. The decoder runs before this script, thus a row is a
+ * record and a cell reads by its column name.
+ */
+export declare const CHART_SERIES_BUILDER: string;
 /**
  * The page-side script that wires each chart. It finds every chart container, reads the option JSON from
  * the sibling `<script type="application/json">` element, and initializes ECharts with the registered
  * theme. The skeleton registers the theme before this script runs. A resize handler keeps each chart
  * fit to the window.
  *
+ * An option that carries the data-source member holds no row. The script then reads the registered payload
+ * of the artifact and builds the data of each series from the descriptors. A mount whose payload the
+ * registry does not hold keeps its empty card, and the walk continues.
+ *
  * The script signals readiness when the bootstrap completes, and immediately when no chart exists. It sets
  * the `window.__inflexaThemeReady` sentinel and dispatches the `inflexa-theme-ready` event on the document.
  * A reader that captures the page keys on this signal, thus the capture returns when the page is ready and
@@ -65,3 +97,87 @@ export declare const CHART_BOOTSTRAP: string;
  * element without this script.
  */
 export declare const FADE_IN_OBSERVER = "(function () {\n  var waiting = [];\n  var settled = false;\n  function settle() {\n    if (settled) {\n      return;\n    }\n    settled = true;\n    for (var w = 0; w < waiting.length; w++) {\n      waiting[w]();\n    }\n    waiting = [];\n  }\n  window.__inflexaWhenRevealed = function (done) {\n    if (settled) {\n      done();\n      return;\n    }\n    waiting.push(done);\n  };\n  function reveal(node) {\n    node.classList.add(\"fade-in-visible\");\n  }\n  function revealSettled(node) {\n    node.classList.add(\"fade-in-instant\");\n    node.classList.add(\"fade-in-visible\");\n  }\n  function start() {\n    var nodes = document.querySelectorAll(\".fade-in\");\n    if (typeof IntersectionObserver === \"undefined\" || nodes.length === 0) {\n      for (var i = 0; i < nodes.length; i++) {\n        revealSettled(nodes[i]);\n      }\n      settle();\n      return;\n    }\n    var firstPass = true;\n    var observer = new IntersectionObserver(function (entries) {\n      var instant = firstPass;\n      firstPass = false;\n      for (var j = 0; j < entries.length; j++) {\n        var entry = entries[j];\n        if (!entry.isIntersecting) {\n          continue;\n        }\n        var target = entry.target;\n        observer.unobserve(target);\n        if (instant) {\n          revealSettled(target);\n          continue;\n        }\n        var delay = parseInt(target.getAttribute(\"data-delay\") || \"0\", 10) || 0;\n        setTimeout(reveal.bind(null, target), delay);\n      }\n      if (instant) {\n        settle();\n      }\n    }, { threshold: 0 });\n    for (var k = 0; k < nodes.length; k++) {\n      observer.observe(nodes[k]);\n    }\n    setTimeout(settle, 2000);\n  }\n  if (document.readyState === \"loading\") {\n    document.addEventListener(\"DOMContentLoaded\", start);\n  } else {\n    start();\n  }\n})();";
+/**
+ * The page-side script that marks the navigation link of the section in view.
+ *
+ * Each navigation anchor targets one top-level section by its id. The script resolves each anchor to its
+ * section, and an `IntersectionObserver` over those sections drives the active class. The observation box
+ * covers the top band of the viewport alone, thus the script marks the first section of that band in
+ * document order and exactly one link carries the class.
+ *
+ * A section that no anchor targets, and an anchor whose target is absent, drop out of the walk. Thus the
+ * reference band never takes the mark.
+ *
+ * A page can leave the observation box empty. At scroll 0, each section can start below the box. A short
+ * tail also holds the last section below the box for the whole scroll. Thus the paint step has a fallback.
+ * The fallback marks the last section whose top sits at the end of the box or above it. It marks the first
+ * section when every top sits below the box.
+ *
+ * The fallback reads each position with `getBoundingClientRect` at paint time. A scroll moves each section,
+ * thus a cached position names the wrong link. As a result, exactly one link carries the active class on a
+ * page that has a section.
+ *
+ * The highlight is decoration. A browser with no `IntersectionObserver`, and a page with no navigation,
+ * keep the plain links. The script writes one class and it reads nothing that the reveal script writes,
+ * thus the two observers never contend.
+ */
+export declare const SECTION_SPY: string;
+/**
+ * The decoder of the table data assets.
+ *
+ * Each data asset registers its payload under the global map, keyed by the block id. The payload is
+ * columnar: a row is an array in column order, and a number in a column that carries a dictionary is the
+ * index of its value. This script materializes the decoded rows one time, thus a reader of the data takes
+ * plain row objects and no reader repeats the decode.
+ *
+ * The decoded rows land on the payload itself, under `rows`. The encoded arrays stay under `encoded`, thus
+ * the decode runs one time even when the script runs again. A cell of `null` names a column that the row
+ * does not hold, and the decoded row omits that key. Thus a ragged row stays ragged and no key reads as an
+ * empty value.
+ *
+ * The script runs after the data assets and before the page scripts. A page with no table registers no
+ * map, and the guard leaves such a page untouched.
+ */
+export declare const TABLE_DATA_DECODER = "(function () {\n  var registry = window.__REPORT_TABLES;\n  if (!registry) {\n    return;\n  }\n  var ids = Object.keys(registry);\n  for (var i = 0; i < ids.length; i++) {\n    var payload = registry[ids[i]];\n    if (!payload || payload.encoded) {\n      continue;\n    }\n    var columns = payload.columns || [];\n    var dict = payload.dict || {};\n    var encoded = payload.rows || [];\n    var decoded = [];\n    for (var r = 0; r < encoded.length; r++) {\n      var row = encoded[r];\n      // A column name is authored text. A plain object would read an inherited member such as\n      // \"constructor\" as a dictionary, and it would send a \"__proto__\" column to the prototype. The\n      // null-prototype record and the own-key test keep every column name an ordinary entry.\n      var record = Object.create(null);\n      for (var c = 0; c < columns.length; c++) {\n        var cell = row[c];\n        if (cell === null || cell === undefined) {\n          continue;\n        }\n        var name = columns[c];\n        var values = Object.prototype.hasOwnProperty.call(dict, name) ? dict[name] : null;\n        record[name] = values && typeof cell === \"number\" ? values[cell] : cell;\n      }\n      decoded.push(record);\n    }\n    payload.encoded = encoded;\n    payload.rows = decoded;\n  }\n})();";
+/**
+ * The client twin of `formatTableCell`, as browser source text.
+ *
+ * The rows of a table reach the reader through the data asset, thus the page formats each cell. The server
+ * ships the kind of each column, and this fragment reads the cell under that kind: the identifier text, the
+ * bound of a stored zero, the exponent of a small probability, the grouped whole number, the rounded float,
+ * the typographic minus of a negative, and the trim of a delimited name.
+ *
+ * The fragment writes its own constants, because a page script reads no module binding. A shared test vector
+ * runs the server helper and this twin over the same entries, thus the two cannot give different text in
+ * silence. `formatCell` is the one entry point, and the grid boot below inlines the whole fragment.
+ */
+export declare const TABLE_CELL_FORMATTER = "function formatCell(cell, kind, bound) {\n  var text = cellText(cell, kind, bound);\n  var segments = text.split(\"%\");\n  if (segments.length < 3) {\n    return text;\n  }\n  for (var s = 0; s < segments.length; s++) {\n    if (segments[s].length === 0 || /\\s/.test(segments[s])) {\n      return text;\n    }\n  }\n  return segments[0];\n}\nfunction cellText(cell, kind, bound) {\n  if (kind === \"identifier\") {\n    return String(cell).trim();\n  }\n  var value = finiteValue(cell);\n  if (value === null) {\n    return String(cell);\n  }\n  return shownMinus(numberText(value, kind, bound));\n}\nfunction shownMinus(text) {\n  // The leading character alone. An exponent keeps its own hyphen, thus one form reads one notation.\n  return text.charAt(0) === \"-\" ? \"\u2212\" + text.slice(1) : text;\n}\nfunction numberText(value, kind, bound) {\n  if (kind === \"scientific\") {\n    if (value === 0) {\n      return bound !== undefined && bound !== null && bound > 0 ? \"<\" + boundForm(bound) : \"\u2248\" + \"0\";\n    }\n    if (value > 0 && value < 1e-2) {\n      return scientificForm(value);\n    }\n  }\n  if (Number.isSafeInteger(value)) {\n    return compactForm(value);\n  }\n  var magnitude = Math.abs(value);\n  if (value !== 0 && magnitude < 1e-3) {\n    return scientificForm(value);\n  }\n  var rounded = Math.round(magnitude);\n  if (rounded >= 1e3 && rounded < 1e15) {\n    return compactForm(value);\n  }\n  return tidy(value.toPrecision(3));\n}\nfunction finiteValue(cell) {\n  if (typeof cell === \"number\") {\n    return isFinite(cell) ? cell : null;\n  }\n  var trimmed = String(cell).trim();\n  if (trimmed === \"\") {\n    return null;\n  }\n  var parsed = Number(trimmed);\n  return isFinite(parsed) ? parsed : null;\n}\nfunction boundForm(bound) {\n  var parts = bound.toExponential().split(\"e\");\n  var digits = parts[0].replace(\".\", \"\");\n  var raised = Number(digits.charAt(0)) + (digits.length > 1 ? 1 : 0);\n  var carries = raised === 10;\n  var digit = carries ? 1 : raised;\n  var power = Number(parts[1]) + (carries ? 1 : 0);\n  if (power < -2) {\n    return digit + \"e\" + power;\n  }\n  return power >= 0 ? String(digit) + zeros(power) : \"0.\" + zeros(-power - 1) + digit;\n}\nfunction zeros(count) {\n  var text = \"\";\n  for (var z = 0; z < count; z++) {\n    text += \"0\";\n  }\n  return text;\n}\nfunction scientificForm(value) {\n  return tidy(value.toExponential(1));\n}\nfunction compactForm(value) {\n  return (value < 0 ? \"-\" : \"\") + groupDigits(Math.abs(value).toFixed(0));\n}\nfunction groupDigits(digits) {\n  if (!/^[0-9]+$/.test(digits)) {\n    return digits;\n  }\n  var grouped = \"\";\n  for (var d = 0; d < digits.length; d++) {\n    if (d > 0 && (digits.length - d) % 3 === 0) {\n      grouped += \",\";\n    }\n    grouped += digits.charAt(d);\n  }\n  return grouped;\n}\nfunction tidy(text) {\n  var marker = text.indexOf(\"e\");\n  if (marker < 0) {\n    return trimZeros(text);\n  }\n  return trimZeros(text.slice(0, marker)) + \"e\" + text.slice(marker + 1).replace(\"+\", \"\");\n}\nfunction trimZeros(text) {\n  if (text.indexOf(\".\") < 0) {\n    return text;\n  }\n  var end = text.length;\n  while (end > 0 && text.charAt(end - 1) === \"0\") {\n    end -= 1;\n  }\n  if (text.charAt(end - 1) === \".\") {\n    end -= 1;\n  }\n  return text.slice(0, end);\n}";
+/**
+ * The page-side script that builds one grid for each table block.
+ *
+ * The script walks the grid mounts. Each mount names its block, and the registry holds the decoded rows and
+ * the column display of that block. Thus the boot reads what the server resolved, and it resolves nothing
+ * again. A mount whose block the registry does not hold keeps its empty card, and the walk continues.
+ *
+ * The column definition takes the label, the filter, and the two readings of a cell. The formatter gives the
+ * shown text under the kind of the column, and the tooltip gives the raw cell where the shown text differs
+ * from it. A value getter reads the own key of the row, because the field of a column reads a point as a
+ * path and a column name can hold one. A number column also parses the cell for its filter, thus a column
+ * of numeric text compares as a number and a sentinel matches nothing.
+ *
+ * The row model is the client-side model. It renders the visible slice alone, thus a table of many thousands
+ * of rows costs the DOM a screen of rows. The mount takes the height of its rows, up to the visible count,
+ * thus a short table leaves no empty box under it. A wide table adds the horizontal scroll bar that the
+ * host paints, measured at the first data render, thus the bar covers no row.
+ *
+ * The status of the card reads the model of the grid. The grid gives a model event after each filter and
+ * each sort, thus the count states what the reader sees against what the table holds.
+ *
+ * The print hooks switch the grid to its print layout. That layout lays every row out at once and it holds
+ * no scroll viewport, thus each row of the print form reaches the paper. The print stops at the print bound,
+ * and the note of the card then states what the paper shows and where the whole table is.
+ *
+ * One grid builds inside a guard. A malformed payload is exactly the fault that a look must diagnose, thus
+ * it must never stop a sibling grid and it must never throw out of the page.
+ */
+export declare const GRID_BOOTSTRAP: string;