quario 0.1.0 → 0.3.0

package/lib/scope.js

@@ -119,12 +119,6 @@ let RUNNERS = {
     };
   },
 };
-/** @type {(fold: Fold) => Eval} */
-let startRunner = ({ fn, per }) => {
-  let step = RUNNERS[fn]();
-  return (scope) => step(per ? per(scope) : 1);
-};
-
 // The runner set as a value, and the two things a band does with it. `extend`
 // is the whole of persist-vs-reset: a group's own runners are fresh per
 // instance, the outer ones fold on unchanged.
@@ -136,10 +130,10 @@ let runnerSet = (runners) => {
       // Declaring no runners is not a change of set, so a band whose `run`
       // block is absent renders under this very value rather than a copy.
       if (!folds.length) return value;
-      let started = folds.map(([name, fold]) => /** @type {[string, Eval]} */ ([
-        name,
-        startRunner(fold),
-      ]));
+      let started = folds.map(([name, { fn, per }]) => {
+        let step = RUNNERS[fn]();
+        return /** @type {[string, Eval]} */ ([name, (scope) => step(per ? per(scope) : 1)]);
+      });
       return runnerSet([...runners, ...started]);
     },
     // The per-row detail scope: `@` bound to the row, its running values folded

package/lib/stream.js

@@ -8,15 +8,15 @@
  * loop back is a stream rule — the two are independent, and a target breathes
  * while stamping finished pages, which is no walk at all (CONTEXT.md).
  */
-// The token-join sjabloon renders with: literals verbatim, values
-// `String(value ?? '')`. Re-exported so event consumers derive display text
-// from a cell's tokens without hand-rolling the join.
-export { text } from "sjabloon";
+// The token-join sjabloon renders with — literals verbatim, values through
+// the scalar `display()` rule — re-exported together so event consumers
+// derive display text from a cell's tokens without hand-rolling the join.
+export { display, text } from "sjabloon";
 
 /** @type {(value: any) => boolean} */
-let finiteNum = (value) => typeof value === "number" && Number.isFinite(value);
+export let finiteNum = (value) => typeof value === "number" && Number.isFinite(value);
 /** @type {(value: any) => boolean} */
-let finiteDate = (value) => value instanceof Date && Number.isFinite(value.getTime());
+export let finiteDate = (value) => value instanceof Date && Number.isFinite(value.getTime());
 /** @type {(value: any) => number | boolean | Date | undefined} */
 let asTyped = (value) => {
   if (finiteNum(value)) return value;
@@ -42,7 +42,7 @@ export function typed(tokens) {
 
 // The report's own bands, by the role their items wear (CONTEXT.md, "Band").
 // The page ones are in it although no walk emits them: the question is whose
-// band a role names, not what a walk hands over (ADR 0021).
+// band a role names, not what a walk hands over (ADR 0028).
 let REPORT_BANDS = new Set([
   "report-header",
   "report-footer",
@@ -55,7 +55,7 @@ let REPORT_BANDS = new Set([
  * Whether a band item's `role` names one of the report's own bands rather than
  * a group instance's. This says whose band it is, never how to lay one out —
  * what a consumer does with the answer is its own. See SCHEMA.md ("Event
- * stream") for the contract and ADR 0021 for why the engine classifies rather
+ * stream") for the contract and ADR 0028 for why the engine classifies rather
  * than carrying a verdict on the events themselves.
  *
  * @param {string} role An item or image event's `role`.

package/lib/style.js

@@ -19,12 +19,21 @@ let spec = (msg, ok) => ({ ok, msg });
 let COLOR = spec("expected a #rgb or #rrggbb color", isHex);
 let FLAG = spec("expected a boolean", (value) => typeof value === "boolean");
 let ALIGNMENTS = ["left", "center", "right"];
-// The declarations an image item accepts. The rest of the vocabulary describes
-// text, which an image does not have, so anything else on one is a definition
-// error rather than a silent no-op (SCHEMA.md, "Image item"). The subset lives
-// beside the vocabulary it narrows, and `checkImageStyle` below is how the
-// traversal asks for it -- it keeps no second list of its own.
+let LINES = ["solid", "dashed", "dotted"];
+let SIDES = ["Top", "Right", "Bottom", "Left"];
+let BORDER_PARTS = ["Width", "Style", "Color"];
+// The declarations an image item accepts. Text names are refused; the box and
+// flow spacing are legal, because a band image has a box and sits in the flow
+// the way a text item does (SCHEMA.md, "Image item"). The subset lives beside
+// the vocabulary it narrows, and `checkImageStyle` below is how the traversal
+// asks for it -- it keeps no second list of its own.
 let IMAGE_STYLES = ["align", "background"];
+// The declarations a report default accepts. A report default states what the
+// document is set in, so it carries only the two declarations that describe a
+// typeface -- and, unlike the rest of the vocabulary, only the two no band-role
+// default has to argue with. Anything else is a definition error rather than a
+// silent no-op, exactly as on an image (SCHEMA.md, "Report default").
+let REPORT_STYLES = ["family", "size"];
 /** @type {Record<string, StyleSpec>} */
 let STYLES = {
   family: spec(
@@ -36,10 +45,34 @@ let STYLES = {
   italic: FLAG,
   underline: FLAG,
   strikethrough: FLAG,
+  uppercase: FLAG,
   color: COLOR,
   background: COLOR,
   align: spec("expected left, center, or right", (value) => ALIGNMENTS.includes(value)),
+  format: spec("expected number, currency, percent, or date", (value) => FORMATS.includes(value)),
 };
+let FORMATS = ["number", "currency", "percent", "date"];
+let POINTS = spec(
+  "expected a non-negative number of points",
+  (value) => finite(value) && value >= 0,
+);
+let LINE = spec("expected solid, dashed, or dotted", (value) => LINES.includes(value));
+/** @type {Record<string, StyleSpec>} */
+let BORDER = { Width: POINTS, Style: LINE, Color: COLOR };
+for (let side of SIDES) {
+  STYLES["padding" + side] = POINTS;
+  IMAGE_STYLES.push("padding" + side);
+  for (let part of BORDER_PARTS) {
+    let name = "border" + side + part;
+    STYLES[name] = BORDER[part];
+    IMAGE_STYLES.push(name);
+  }
+}
+let FLOW = ["spaceBefore", "spaceAfter"];
+for (let name of FLOW) {
+  STYLES[name] = POINTS;
+  IMAGE_STYLES.push(name);
+}
 // One check for both the validating traversal and the compile path: an error
 // message for a declaration, or null when it is acceptable (expressions defer
 // to render).
@@ -55,12 +88,71 @@ export let checkStyle = (name, value) => {
   return rule.ok(value) ? null : rule.msg;
 };
 
-// The same check narrowed to what an image accepts, so a text declaration on
-// one is refused as pointedly as an unknown name. A node that takes part of
-// the vocabulary names this checker rather than passing a flag, which is what
-// keeps the subset and its wording here, together.
-/** @type {(name: string, value: any) => string | null} */
-export let checkImageStyle = (name, value) =>
-  Object.hasOwn(STYLES, name) && !IMAGE_STYLES.includes(name)
-    ? 'style "' + name + '" does not apply to an image'
+// A border side is width, style, and colour together, or none. Incomplete
+// literals are a definition error; a side that still has an expression defers
+// to render, where an incomplete result contributes nothing rather than
+// becoming a solid black stroke. Per-name checks run first; a side that
+// already has a located problem is left alone so the author sees one cause.
+/** @type {(present: string[]) => boolean} */
+let incomplete = (present) => present.length > 0 && present.length < 3;
+/** @type {(block: any, check: (name: string, value: any) => string | null, name: string) => boolean} */
+let deferred = (block, check, name) => isExpr(block[name]) || !!check(name, block[name]);
+
+/** @type {(block: any, check?: (name: string, value: any) => string | null) => [string, string][]} */
+export let checkBorderSides = (block, check = checkStyle) => {
+  /** @type {[string, string][]} */
+  let out = [];
+  for (let side of SIDES) {
+    let names = BORDER_PARTS.map((part) => "border" + side + part);
+    let present = names.filter((name) => Object.hasOwn(block, name));
+    if (incomplete(present) && !present.some((name) => deferred(block, check, name)))
+      out.push([present[0], "border" + side + " needs width, style, and color together"]);
+  }
+  return out;
+};
+
+// The same check narrowed to a subset of the vocabulary, so a declaration a
+// node cannot wear is refused as pointedly as an unknown name rather than
+// silently doing nothing. A node that takes part of the vocabulary names the
+// checker this makes rather than passing a flag, which is what keeps each
+// subset and its wording together, here.
+//
+// `subject` completes "does not apply to ___", so it carries its own article.
+/** @type {(allowed: string[], subject: string) => (name: string, value: any) => string | null} */
+let narrowed = (allowed, subject) => (name, value) =>
+  Object.hasOwn(STYLES, name) && !allowed.includes(name)
+    ? 'style "' + name + '" does not apply to ' + subject
     : checkStyle(name, value);
+
+export let checkImageStyle = narrowed(IMAGE_STYLES, "an image");
+// "a report default" rather than the key's name: the key is `style` like every
+// other one, so the message has to say which `style` refused it.
+export let checkReportStyle = narrowed(REPORT_STYLES, "a report default");
+
+// Flow spacing is a band-item pad. A table cell, a row box, and a split slot
+// have no flow, so the names are refused there the way a text declaration is
+// on an image (docs/adr/0037).
+/** @type {Record<string, true>} */
+let FLOW_NAMES = Object.fromEntries(FLOW.map((name) => [name, true]));
+/**
+ * @type {(names: Record<string, true>, check: (name: string, value: any) => string | null, subject: string) =>
+ *   (name: string, value: any) => string | null}
+ */
+let withoutNames = (names, check, subject) => (name, value) =>
+  Object.hasOwn(names, name)
+    ? 'style "' + name + '" does not apply to ' + subject
+    : check(name, value);
+/**
+ * @type {(check: (name: string, value: any) => string | null, subject: string) =>
+ *   (name: string, value: any) => string | null}
+ */
+let withoutFlow = (check, subject) => withoutNames(FLOW_NAMES, check, subject);
+
+export let checkCellStyle = withoutFlow(checkStyle, "a table cell");
+export let checkSlotStyle = withoutFlow(checkStyle, "a split slot");
+export let checkSlotImageStyle = withoutFlow(checkImageStyle, "a split slot");
+// A row box has no cell value, so `format` is refused there the way flow
+// spacing is — it is a presentation of a value, not of a band of cells.
+/** @type {Record<string, true>} */
+let ROW_NAMES = { ...FLOW_NAMES, format: true };
+export let checkRowStyle = withoutNames(ROW_NAMES, checkStyle, "a table row");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quario",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "A tiny, runtime-neutral report engine — in the makings, not yet released",
   "homepage": "https://getquario.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -33,9 +33,9 @@
     "postpack": "node -e \"require('fs').rmSync('LICENSE',{force:true})\""
   },
   "dependencies": {
-    "padvinder": "^0.4.0",
-    "sjabloon": "^0.8.0",
-    "xprsn": "^0.9.0"
+    "padvinder": "^0.9.0",
+    "sjabloon": "^0.12.0",
+    "xprsn": "^0.11.1"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.3",
@@ -51,7 +51,7 @@
         "sjabloon",
         "padvinder"
       ],
-      "limit": "8 kB"
+      "limit": "10 kB"
     }
   ],
   "engines": {