@stapel/listings-react 0.24.0 → 0.25.1

package/src/model/draft.ts

@@ -171,7 +171,11 @@ export function draftValuesFromDetail(
 ): ListingDraftValues {
   const base = emptyDraftValues(options);
   return {
-    categoryId: detail.category_id,
+    // `text()` for the same reason as the draft seed above: 0.21.4 answers
+    // `category_id: null` for a row created before its category was chosen,
+    // and a seed that took it verbatim put `null` where a string is declared
+    // and crashed the first control that measured its length.
+    categoryId: text(detail.category_id),
     title: text(detail.title),
     description: text(detail.description),
     price: text(detail.price),
@@ -236,7 +240,11 @@ export function draftPatchFromValues(
   features: readonly FeatureDef[]
 ): ListingDraftPatch {
   return {
-    category_id: values.categoryId,
+    // Omitted while unchosen rather than sent as `""`: a draft is allowed to
+    // have no category (0.21.4), and `""` is not "no category" on the wire —
+    // it is an empty id the serializer refuses. The category is written by
+    // whichever save follows the pick.
+    ...(values.categoryId.length > 0 ? { category_id: values.categoryId } : {}),
     title_draft: values.title,
     description_draft: values.description,
     price_draft: values.price.length > 0 ? values.price : null,
@@ -261,16 +269,26 @@ export function draftPatchFromValues(
 }
 
 /**
- * The body for CREATING a draft: `category_id` and nothing else.
+ * The body for CREATING a draft: the category if there is one, `{}` if there
+ * is not.
  *
  * `perform_create` forces `owner` and `status`, and everything else has a
  * model default, so a create that also carried the form's current contents
  * would be a second write of data the very next `save-draft` sends anyway —
  * and would fail the whole submission on a field the person could still fix.
  * Create the row, then save into it.
+ *
+ * `{}` IS a valid create body since stapel-listings 0.21.4 made `category_id`
+ * nullable on a draft: a draft may exist before its category is chosen, and
+ * `publish` is where the category becomes mandatory (`publish_validation
+ * _failed` naming `category_id`). Not being able to create the row first is
+ * what left an analysis job addressed by the draft id with no id to start
+ * from (D261).
  */
-export function createDraftBody(categoryId: string): ListingDraftPatch {
-  return { category_id: categoryId };
+export function createDraftBody(categoryId?: string): ListingDraftPatch {
+  return categoryId !== undefined && categoryId.length > 0
+    ? { category_id: categoryId }
+    : {};
 }
 
 /**

package/src/model/featureText.ts

@@ -43,6 +43,28 @@
  * the same answer typeset — same value, same precision rule, same
  * `postfix1000` switch at a thousand, same translated unit, with the digits
  * run through `Intl.NumberFormat` instead of `String()`.
+ *
+ * ── Which numbers are grouped, and which are not (D307) ────────────────────
+ *
+ * Grouping every number is how a card came to read "2 024" for a model year.
+ * A year is not a quantity: it is an identifier spelled in digits, and so is
+ * a house number, a floor, a room count. Grouping them is not a nicety
+ * applied too widely, it is the wrong reading.
+ *
+ * The rule is the one fact the catalogue already states, plus a magnitude no
+ * identifier reaches:
+ *
+ *  - a feature that carries a UNIT (`prefix`, `postfix`, `postfix1000`) is a
+ *    measurement — "20 000 km", "173 hp", "42 m²" — and is grouped;
+ *  - a unitless value is grouped only from 10 000 up. A year is four digits
+ *    for the next eight thousand of them and a count of doors is one, so the
+ *    threshold sorts years from counts WITHOUT a "does this slug look like a
+ *    year" heuristic — which is guesswork the moment a deployment names the
+ *    slug in its own language.
+ *
+ * Grouping is switched off through `Intl` rather than around it, so a unitless
+ * float still gets the reader's DECIMAL MARK ("2,5", not "2.5"): the two are
+ * separate defects and only one of them is being repaired here.
  */
 import type { FeatureDef, FeatureValueDto, FormatOptions } from "@stapel/attributes-react";
 import { featureConfig, featureType, formatFeatureValue } from "@stapel/attributes-react";
@@ -102,17 +124,42 @@ export function featureUnit(
  * because a host passed `"en_US"` would be a worse outcome than an ungrouped
  * number — so the caller falls back rather than the page failing.
  */
-function grouped(value: number, digits: number, locale: string | undefined): string | undefined {
+function localized(
+  value: number,
+  digits: number,
+  locale: string | undefined,
+  useGrouping: boolean
+): string | undefined {
   try {
     return new Intl.NumberFormat(locale, {
       minimumFractionDigits: digits,
       maximumFractionDigits: digits,
+      useGrouping,
     }).format(value);
   } catch {
     return undefined;
   }
 }
 
+/** Digits below which a unitless number is an identifier rather than a
+ * quantity — see the module header. */
+const GROUPING_FLOOR = 10_000;
+
+/**
+ * Does this feature measure something?
+ *
+ * The RAW config, not the translated unit: whether a value is a measurement
+ * is a fact about the catalogue, and it must not change because a host's
+ * message catalogue happens to resolve a unit key to an empty string.
+ */
+function hasUnit(config: Readonly<Record<string, unknown>>): boolean {
+  return (
+    str(config["prefix"]).length > 0 ||
+    str(config["postfix"]).length > 0 ||
+    str(config["postfix1000"]).length > 0
+  );
+}
+
 /**
  * The one numeric row, typeset — see the module header for what each piece
  * is repairing.
@@ -150,7 +197,8 @@ function formatNumeric(
   if (postfix1000.length > 0 && Math.abs(parsed) >= 1000) {
     const scaled = Number((parsed / 1000).toFixed(digits));
     const body =
-      grouped(scaled, decimalsOf(scaled, digits), options?.locale) ?? String(scaled);
+      localized(scaled, decimalsOf(scaled, digits), options?.locale, true) ??
+      String(scaled);
     return join(prefix, body, translated(options, postfix1000));
   }
 
@@ -160,7 +208,11 @@ function formatNumeric(
   // a year field and the card read "2024.0").
   const value = kind === "int" ? Math.trunc(parsed) : parsed;
   const fraction = kind === "int" ? 0 : digits;
-  const body = grouped(value, fraction, options?.locale) ?? value.toFixed(fraction);
+  // A measurement is grouped; a unitless number is an identifier until it is
+  // too big to be one (D307 — the card read "2 024" for a model year).
+  const group = hasUnit(config) || Math.abs(value) >= GROUPING_FLOOR;
+  const body =
+    localized(value, fraction, options?.locale, group) ?? value.toFixed(fraction);
   return join(prefix, body, translated(options, config["postfix"]));
 }