@umriss-ui/calculation 0.41.1 → 0.42.0

package/dist/calculation.model-DU6T1D09.js

@@ -0,0 +1,168 @@
+import { Children as ie, isValidElement as b, Fragment as oe } from "react";
+const d = (o) => Object.defineProperty(() => {
+  throw new Error(
+    `@umriss-ui/calculation: <${o}> stands only directly inside a <Calculation>. A tree written in a Server Component must be written inside the <Calculation> there, in one file, not passed through a client component.`
+  );
+}, "name", { value: o }), ae = d("Given"), se = d("Sum"), re = d("Difference"), ce = d("Product"), ue = d("Quotient"), J = d("Ref"), le = d("Chain"), fe = d("Plus"), de = d("Minus"), pe = d("Times"), me = d("DividedBy"), x = d("Interim"), he = /* @__PURE__ */ new Map([
+  [se, "sum"],
+  [re, "difference"],
+  [ce, "product"],
+  [ue, "quotient"]
+]), U = {
+  sum: "Sum",
+  difference: "Difference",
+  product: "Product",
+  quotient: "Quotient"
+}, Q = /* @__PURE__ */ new Map([
+  [fe, { name: "Plus", operator: "sum" }],
+  [de, { name: "Minus", operator: "sum", negated: !0 }],
+  [pe, { name: "Times", operator: "product" }],
+  [me, { name: "DividedBy", operator: "quotient" }]
+]), B = "<Given>, <Sum>, <Difference>, <Product>, <Quotient> or <Chain>", Y = "a calculation with metrics only adds and subtracts - <Sum>, <Difference>, <Plus>, <Minus>.", $e = ["unit", "format", "decimals"];
+function a(o) {
+  throw new Error(`@umriss-ui/calculation: ${o}`);
+}
+function S(o) {
+  return ie.toArray(o).flatMap(
+    (n) => b(n) && n.type === oe ? S(n.props.children) : [n]
+  );
+}
+function E(o) {
+  if (!b(o)) return JSON.stringify(o);
+  const n = o.type;
+  return typeof n == "string" ? `<${n}>` : `<${n.displayName ?? n.name ?? "anonymous"}>`;
+}
+const G = (o, n, f) => `${o}/${b(n) && n.key || f}`;
+function ge(o, n) {
+  const f = S(o);
+  if (f.length !== 1 && a(`<Calculation> takes exactly one child, the result; it was given ${f.length}.`), n !== void 0) {
+    n.length === 0 && a("<Calculation>: metrics is empty; leave it out for a calculation with one number per quantity.");
+    const t = /* @__PURE__ */ new Set();
+    for (const { id: i } of n)
+      t.has(i) && a(`<Calculation>: the metric id "${i}" is used twice.`), t.add(i);
+  }
+  const y = n?.map((t) => `"${t.id}"`).join(", "), r = (t, i) => {
+    const s = typeof t == "object" && t !== null;
+    if (n === void 0) {
+      s && a(`${i}: value is an object by metric, but the calculation has no metrics.`);
+      return;
+    }
+    s || a(`${i}: with metrics, value is an object with a number for each metric - ${y}.`);
+    for (const { id: e } of n)
+      e in t || a(`${i}: value has no number for the metric "${e}"; write null where it is absent. The metrics: ${y}.`);
+    for (const e of Object.keys(t))
+      n.some((c) => c.id === e) || a(`${i}: value has a number for "${e}", which is no metric. The metrics: ${y}.`);
+  }, m = /* @__PURE__ */ new Map(), v = /* @__PURE__ */ new Map(), P = [], R = (t, i, s) => {
+    const { id: e, ...c } = i;
+    if (n !== void 0) {
+      for (const w of $e)
+        i[w] !== void 0 && a(`${s}: ${w} belongs to the metric once the calculation has metrics, not to a quantity.`);
+      (i.target !== void 0 || i.limits !== void 0) && a(`${s}: target and limits are not assessed in a calculation with metrics.`);
+    }
+    e !== void 0 && (v.has(e) && a(`${s}: the id "${e}" is used twice.`), v.set(e, t));
+    const h = { ...c, key: t, id: e, operands: [] };
+    return m.set(t, h), h;
+  }, N = (t, i, s) => {
+    if (b(t) && t.type === J) {
+      const e = { key: "", reference: !0 };
+      return P.push({ operand: e, to: t.props.to, where: s }), e;
+    }
+    return { key: L(t, i, s), reference: !1 };
+  }, L = (t, i, s) => {
+    if ((!b(t) || t.type === J || Q.has(t.type) || t.type === x) && a(`${s}: ${E(t)} cannot stand here; a quantity must be ${B}.`), t.type === le) return z(t.props.children, i, s);
+    const e = he.get(t.type);
+    t.type !== ae && e === void 0 && a(
+      `${s}: ${E(t)} is not an element of the calculation. A calculation reads its children's props and cannot look inside a component of your own; write ${B} or <Ref> directly, or return them from .map.`
+    );
+    const { children: c, value: h, source: w, asOf: I, ages: p, ...q } = t.props, u = `${s} › ${q.label}`;
+    n !== void 0 && (e === "product" || e === "quotient") && a(`${u}: <${U[e]}> - ${Y}`);
+    const C = R(i, q, u);
+    if (e === void 0)
+      return r(h, u), C.given = { value: h, source: w, asOf: I, ages: p }, i;
+    C.operator = e;
+    const $ = S(c), l = $.length;
+    return (e === "quotient" ? l !== 2 : e !== "sum" && l < 2) && a(
+      `${u}: <${U[e]}> takes ${e === "quotient" ? "exactly two operands" : "two or more operands"}; it was given ${l}.`
+    ), C.operands = $.map((O, T) => N(O, G(i, O, T), u)), i;
+  }, z = (t, i, s) => {
+    const e = `${s} › <Chain>`, [c, ...h] = S(t);
+    (c === void 0 || b(c) && (Q.has(c.type) || c.type === x)) && a(`${e}: a chain starts with a quantity that has no operator - ${B} or <Ref>.`);
+    let w = N(c, G(i, c, 0), e), I = E(c), p = [], q;
+    return h.forEach((u, C) => {
+      const $ = G(i, u, C + 1);
+      if (b(u) && u.type === x) {
+        const g = u.props, D = `${e} › ${g.label}`;
+        p.length === 0 && a(`${D}: an <Interim> needs an operand since the named value before it, ${I}.`);
+        const A = R($, g, D);
+        A.interim = !0, A.operator = p[0].line.operator, A.operands = [w, ...p.map((ne) => ne.operand)], w = { key: $, reference: !1, previous: !0 }, I = `<Interim label="${g.label}">`, p = [], q = $;
+        return;
+      }
+      const l = b(u) ? Q.get(u.type) : void 0;
+      l === void 0 && a(`${e}: ${E(u)} needs an operator in a chain - <Plus>, <Minus>, <Times> or <DividedBy> - or is an <Interim>.`), n !== void 0 && l.operator !== "sum" && a(`${e}: <${l.name}> - ${Y}`);
+      const O = l.operator !== "sum", T = p.find((g) => g.line.operator !== "sum");
+      (O && p.length > 0 || T) && a(
+        `${e}: <${(T ?? { line: l }).line.name}> stands alone between two named values - directly after the first quantity or an <Interim>, and directly before an <Interim>.`
+      );
+      const { children: H, ...M } = u.props, k = S(H), K = () => a(`${e}: <${l.name}> takes either a label and a value, or exactly one quantity as its child.`);
+      if (k.length > 0) {
+        (k.length > 1 || Object.values(M).some((D) => D !== void 0)) && K();
+        const g = N(k[0], $, e);
+        g.negated = l.negated, p.push({ operand: g, line: l });
+        return;
+      }
+      M.label === void 0 && K();
+      const { value: V, source: W, asOf: X, ages: Z, ...ee } = M, F = `${e} › ${M.label}`, te = R($, { ...ee, label: M.label }, F);
+      r(V, F), te.given = { value: V, source: W, asOf: X, ages: Z }, p.push({ operand: { key: $, reference: !1, negated: l.negated }, line: l });
+    }), (p.length > 0 || q === void 0) && a(`${e}: a chain ends with an <Interim>, which names its value.`), q;
+  }, _ = L(f[0], "0", "<Calculation>"), j = m.get(_);
+  (j.emphasis !== void 0 || j.rule !== void 0) && a(`<Calculation> › ${j.label}: emphasis and rule do not stand on the Result, which is already the heaviest line.`);
+  for (const { operand: t, to: i, where: s } of P) {
+    const e = v.get(i);
+    if (e === void 0) {
+      const c = [...v.keys()].map((h) => `"${h}"`).join(", ");
+      a(`${s}: <Ref to="${i}"> names no quantity. ${c ? `The ids that exist: ${c}.` : "No quantity has an id."}`);
+    }
+    t.key = e;
+  }
+  return ye(m), { result: _, quantities: m, metrics: n };
+}
+function be(o) {
+  return o.metrics ? o.metrics.map((n) => {
+    const f = /* @__PURE__ */ new Map();
+    for (const [y, r] of o.quantities) {
+      const m = r.given && { ...r.given, value: r.given.value[n.id] };
+      f.set(y, { ...r, unit: n.unit, decimals: n.decimals, given: m });
+    }
+    return { result: o.result, quantities: f };
+  }) : [o];
+}
+function ye(o) {
+  const n = /* @__PURE__ */ new Set(), f = [], y = (r) => {
+    if (n.has(r)) return;
+    const m = f.indexOf(r);
+    if (m !== -1) {
+      const v = [...f.slice(m), r].map((P) => o.get(P).label);
+      a(`the calculation goes round in a circle through references: ${v.join(" → ")}.`);
+    }
+    f.push(r);
+    for (const v of o.get(r).operands) y(v.key);
+    f.pop(), n.add(r);
+  };
+  for (const r of o.keys()) y(r);
+}
+export {
+  le as C,
+  re as D,
+  ae as G,
+  x as I,
+  de as M,
+  fe as P,
+  ue as Q,
+  J as R,
+  se as S,
+  pe as T,
+  me as a,
+  ce as b,
+  be as p,
+  ge as r
+};

package/dist/index.d.ts

@@ -10,7 +10,7 @@ import { ReactNode } from 'react';
  operation it shows, the number cannot disagree with the lines above it.
  Every tree below the outermost statement starts folded and opens beneath
  the row that is clicked. */
-export declare function Calculation({ children, className, style, metrics, density, ...rest }: CalculationProps): JSX.Element;
+export declare function Calculation({ children, metrics, ...rest }: CalculationProps): JSX.Element;
 
 /** `className` and `style` size and place the surface; every other attribute -
  `aria-label` first of all - lands on the list the surface holds. */

package/docs/llms-full.md

@@ -1,4 +1,4 @@
-# @umriss-ui/calculation 0.41.1
+# @umriss-ui/calculation 0.42.0
 
 > React calculation view for data-dense applications - a derivation written as it is shown, evaluated by the library, folded and read line by line.
 
@@ -1567,7 +1567,7 @@ Also takes every attribute of the rendered element – without `children`.
 - No result, formula text or operator of your own: a written-out operation the library did not perform could say something the number does not ([ADR-0027](https://github.com/romanhaendler/umriss-ui/blob/main/docs/adr/0027-a-calculation-is-written-as-it-is-shown.md)).
 - No input: a calculation shows how a figure came about; changing a given is your application's form.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.42.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Tree
 
@@ -1848,7 +1848,7 @@ type Severity = "warning" | "alarm";
 - Four operators and nothing else – no powers, roots or functions; compute those before and hand them in as givens.
 - A unit is a label and is never converted or checked; the calculation does no unit algebra.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.42.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Chain
 
@@ -2196,7 +2196,7 @@ type Severity = "warning" | "alarm";
 
 - A chain in view does not fold; as an operand of a tree it folds to its last interim.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.42.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Rows from data
 
@@ -2636,7 +2636,7 @@ From `Metric` — the full table stands on [Metrics](#metrics).
 
 - Only a sum takes any count: an empty product, a difference of one and a quotient of anything but two still fail on the first render.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.42.0/docs/adr/0032-what-umriss-is-not.md).
 
 ### Given
 
@@ -3322,7 +3322,7 @@ The keys of [Calculation](#calculation) apply here.
 - Unit, format and places belong to the metric; on a quantity they fail on the first render, and so does a missing or unknown metric key in a `value`.
 - No target or limits with metrics: an assessment per cell is not there yet.
 
-What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.41.1/docs/adr/0032-what-umriss-is-not.md).
+What umriss deliberately does not build, and why: [ADR-0032](https://github.com/romanhaendler/umriss-ui/blob/calculation-v0.42.0/docs/adr/0032-what-umriss-is-not.md).
 
 ## In practice
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umriss-ui/calculation",
-  "version": "0.41.1",
+  "version": "0.42.0",
   "description": "React calculation view for data-dense applications - a derivation written as it is shown, evaluated by the library, folded and read line by line.",
   "license": "MIT",
   "author": "Roman Händler",
@@ -47,7 +47,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/calculation.js"
+      "import": "./dist/calculation.js",
+      "default": "./dist/calculation.js"
     },
     "./styles.css": {
       "types": "./dist/styles.d.ts",
@@ -55,9 +56,9 @@
     }
   },
   "peerDependencies": {
+    "@umriss-ui/core": "^0.42.0",
     "react": ">=19",
-    "react-dom": ">=19",
-    "@umriss-ui/core": "^0.41.1"
+    "react-dom": ">=19"
   },
   "devDependencies": {
     "@fontsource/geist-mono": "^5.3.0",
@@ -71,7 +72,7 @@
     "typescript": "^5.6.3",
     "vite": "^6.0.0",
     "vite-plugin-dts": "^4.3.0",
-    "@umriss-ui/core": "0.41.1",
+    "@umriss-ui/core": "0.42.0",
     "@umriss-ui/demo": "0.0.0"
   },
   "scripts": {
@@ -86,6 +87,6 @@
     "check:site": "pnpm run props -- --check",
     "preview:demo": "vite preview --config vite.demo.config.ts --port 4177 --strictPort",
     "test:unit": "vitest run",
-    "check:dist": "node --disable-warning=ExperimentalWarning --experimental-strip-types ../../scripts/check-dist.ts calculation.js calculation.css"
+    "check:dist": "node --disable-warning=ExperimentalWarning --experimental-strip-types ../../scripts/check-dist.ts calculation.js calculation.css calculation.client.js"
   }
 }