@pagefront/lint-commerce 0.8.0 → 0.9.0

package/README.md

@@ -26,8 +26,8 @@ lint with their own catalogue, dispatched by sheet type.
 
 ## Catalogue
 
-Catalogue 0.11.0, targeting format 0.9: 48 product rules (`PDP-E-001` to
-`PDP-E-012`, `PDP-W-001` to `PDP-W-035`, `PDP-I-001`) and 7 organization
+Catalogue 0.14.0, targeting format 0.9: 55 product rules (`PDP-E-001` to
+`PDP-E-015`, `PDP-W-001` to `PDP-W-039`, `PDP-I-001`) and 7 organization
 rules (`ORG-E-001`, `ORG-W-001` to `ORG-W-006`), each defined in
 [`rules.md`](https://github.com/themachineweb/pagefront/blob/main/commerce/spec/rules.md)
 with its target, check, message and remediation. Every report carries the
@@ -93,6 +93,33 @@ configurator now fails Layer 1.
 
 Amounts are summed and compared as exact decimals.
 
+Added in 0.9.0 (catalogue 0.14.0), from the same section and from
+["Size guidance"](https://themachineweb.org/pagefront/spec/commerce/product#size-guidance-pagefrontsizechart-and-pagefrontsizerecommendation):
+option values are identifiers, free-text dimensions, order-time services
+kept out of `options`, notes as facts, and size advice in the sizing
+dimension's system. From 0.9.0 every amount is a JSON number or a plain
+decimal string, one carrier per Sheet, and amounts are compared numerically
+whatever the carrier; 0.8.0 validated pricing-block amounts as decimal
+strings only. An Offer's `price`, a variant's `price` and a promotion's
+`discountAmount` no longer accept a string that is not a plain decimal, and
+prices, bounds and base prices no longer accept a negative amount.
+
+- `PDP-E-013` — a dimension declares `inputType: "text"` and enumerates
+  options
+- `PDP-W-036` — an option value looks like a display label (whitespace,
+  an uppercase letter, or a unit suffix); sizing dimensions are exempt
+- `PDP-W-037` — an option in a sizing dimension (`system` of `UK`, `EU`,
+  `US` or `JP`) is not written as a size in that system
+- `PDP-W-032`, `PDP-E-009` and the computed band of `PDP-E-011` now cover
+  the `"*"` modifier of a priced text dimension
+- `PDP-E-014` — a size adjustment's `sizeSystem` is another system than
+  the configurator's sizing dimension
+- `PDP-E-015` — the Sheet's amounts mix JSON numbers and strings
+- `PDP-W-038` — a configurator dimension's `note` reads as page copy
+  (English Sheets: `you`, `your`, `select`, `order`, `contact`)
+- `PDP-W-039` — size advice carries a `description` and no
+  `sizeAdjustment` beside a sizing dimension
+
 ## API
 
 The public surface — everything importable from the package root, and

package/dist/catalogue.js

@@ -10,6 +10,9 @@ import { pdpE009 } from "./rules/pdp-e-009.js";
 import { pdpE010 } from "./rules/pdp-e-010.js";
 import { pdpE011 } from "./rules/pdp-e-011.js";
 import { pdpE012 } from "./rules/pdp-e-012.js";
+import { pdpE013 } from "./rules/pdp-e-013.js";
+import { pdpE014 } from "./rules/pdp-e-014.js";
+import { pdpE015 } from "./rules/pdp-e-015.js";
 import { pdpW001 } from "./rules/pdp-w-001.js";
 import { pdpW002 } from "./rules/pdp-w-002.js";
 import { pdpW003 } from "./rules/pdp-w-003.js";
@@ -45,6 +48,10 @@ import { pdpW032 } from "./rules/pdp-w-032.js";
 import { pdpW033 } from "./rules/pdp-w-033.js";
 import { pdpW034 } from "./rules/pdp-w-034.js";
 import { pdpW035 } from "./rules/pdp-w-035.js";
+import { pdpW036 } from "./rules/pdp-w-036.js";
+import { pdpW037 } from "./rules/pdp-w-037.js";
+import { pdpW038 } from "./rules/pdp-w-038.js";
+import { pdpW039 } from "./rules/pdp-w-039.js";
 import { pdpI001 } from "./rules/pdp-i-001.js";
 /**
  * The commerce product-sheet rule catalogue — the executable form of
@@ -56,6 +63,6 @@ import { pdpI001 } from "./rules/pdp-i-001.js";
 export const commerceCatalogue = {
     vertical: "commerce",
     formatVersion: "0.9",
-    catalogueVersion: "0.11.0",
-    rules: [pdpE001, pdpE002, pdpE003, pdpE004, pdpE005, pdpE006, pdpE007, pdpE008, pdpE009, pdpE010, pdpE011, pdpE012, pdpW001, pdpW002, pdpW003, pdpW004, pdpW005, pdpW006, pdpW007, pdpW008, pdpW009, pdpW010, pdpW011, pdpW012, pdpW013, pdpW014, pdpW015, pdpW016, pdpW017, pdpW018, pdpW019, pdpW020, pdpW021, pdpW022, pdpW023, pdpW024, pdpW025, pdpW026, pdpW027, pdpW028, pdpW029, pdpW030, pdpW031, pdpW032, pdpW033, pdpW034, pdpW035, pdpI001],
+    catalogueVersion: "0.14.0",
+    rules: [pdpE001, pdpE002, pdpE003, pdpE004, pdpE005, pdpE006, pdpE007, pdpE008, pdpE009, pdpE010, pdpE011, pdpE012, pdpE013, pdpE014, pdpE015, pdpW001, pdpW002, pdpW003, pdpW004, pdpW005, pdpW006, pdpW007, pdpW008, pdpW009, pdpW010, pdpW011, pdpW012, pdpW013, pdpW014, pdpW015, pdpW016, pdpW017, pdpW018, pdpW019, pdpW020, pdpW021, pdpW022, pdpW023, pdpW024, pdpW025, pdpW026, pdpW027, pdpW028, pdpW029, pdpW030, pdpW031, pdpW032, pdpW033, pdpW034, pdpW035, pdpW036, pdpW037, pdpW038, pdpW039, pdpI001],
 };

package/dist/organization-catalogue.js

@@ -17,6 +17,6 @@ import { orgW006 } from "./rules/org-w-006.js";
 export const organizationCatalogue = {
     vertical: "commerce",
     formatVersion: "0.9",
-    catalogueVersion: "0.11.0",
+    catalogueVersion: "0.14.0",
     rules: [orgE001, orgW001, orgW002, orgW003, orgW004, orgW005, orgW006],
 };

package/dist/product-schema.js

@@ -10,7 +10,7 @@ export const PRODUCT_SCHEMA = {
     "$schema": "https://json-schema.org/draft/2020-12/schema",
     "$id": "https://themachineweb.org/pagefront/spec/commerce/product/v0.9.json",
     "title": "Pagefront Product Sheet v0.9",
-    "description": "Formal schema for the Pagefront product sheet. Revision of 2026-10-01 (breaking, within v0.9): configurator pricing moves from pagefront:configurator to the offer. The configurator loses basePrice, basePriceCurrency and priceFormula, its options lose priceModifier and currency, and it gains an optional @id and an exclusions[] array; configurator dimensions gain affectsPrice; Offer and AggregateOffer accept pagefront:configuratorPricing, which names the configurator it prices and carries baseConfiguration, basePrice, modifiers, optional adjustments[] and a pricing completeness flag. v0.9 sheets that carried prices inside the configurator no longer validate. v0.9 was otherwise an additive release on top of v0.8: the legalEntity entry's organization now also validates in reference-stub form (@type + @id, no name) so entries can reference a Commerce Organization Sheet; the inline form and all other constraints are unchanged, and v0.8 sheets remain valid once their format_version is updated. v0.8 is an additive release on top of v0.7: it adds a pagefront:featureGroup[] array for grouped, ordered technical specifications (groups of Schema.org PropertyValue entries, with an optional pagefront:presentationValue display variant per entry), a pagefront:productHighlights[] array of ordered publisher-authored selling-point strings, and a pagefront:legalEntity[] array for role-typed legal entities behind a product (closed role enum: brand_owner, licensee, authorized_representative, importer, manufacturer — EU GPSR responsible persons and similar). gtin and gtin13 now accept a string or an array of strings (regional packaging, re-releases); category now accepts the display string, a Schema.org CategoryCode object, or a mixed array of both. The pagefront:Document role enum gains repairability_index, recall_notice, and declaration_of_conformity; the pagefront:RelatedProduct relationship enum gains service. v0.8 also adds two GPSR-driven safety fields: a pagefront:safetyWarning[] array for typed, language-scoped safety warnings (text required; optional pictogram URL and open-vocabulary hazardCategory) and a pagefront:safetyNotice[] array for structured recall/safety notices (closed noticeType enum: recall, warning; closed remedy enum: repair, replacement, refund). v0.7 sheets remain valid under v0.8 once their format_version is updated. Validates the envelope and pagefront-namespaced extensions strictly; Schema.org-typed blocks permit additional unspecified properties.",
+    "description": "Formal schema for the Pagefront product sheet. Revision of 2026-10-01 (breaking, within v0.9): configurator pricing moves from pagefront:configurator to the offer. The configurator loses basePrice, basePriceCurrency and priceFormula, its options lose priceModifier and currency, and it gains an optional @id and an exclusions[] array; configurator dimensions gain affectsPrice, inputType (select or text, for free-text dimensions) and maxLength; Offer and AggregateOffer accept pagefront:configuratorPricing, which names the configurator it prices and carries baseConfiguration, basePrice, modifiers, optional adjustments[] and a pricing completeness flag; every amount field (Offer price, AggregateOffer lowPrice and highPrice, variant price hints, promotion discountAmount, and the pricing block's basePrice, modifiers and adjustment amounts) references a shared definition, a JSON number or a plain decimal string: nonNegativeAmount for prices, bounds, base prices, price hints and discount amounts, and the signed amount for modifiers and adjustment amounts. v0.9 sheets that carried prices inside the configurator no longer validate. v0.9 was otherwise an additive release on top of v0.8: the legalEntity entry's organization now also validates in reference-stub form (@type + @id, no name) so entries can reference a Commerce Organization Sheet; the inline form and all other constraints are unchanged, and v0.8 sheets remain valid once their format_version is updated. v0.8 is an additive release on top of v0.7: it adds a pagefront:featureGroup[] array for grouped, ordered technical specifications (groups of Schema.org PropertyValue entries, with an optional pagefront:presentationValue display variant per entry), a pagefront:productHighlights[] array of ordered publisher-authored selling-point strings, and a pagefront:legalEntity[] array for role-typed legal entities behind a product (closed role enum: brand_owner, licensee, authorized_representative, importer, manufacturer — EU GPSR responsible persons and similar). gtin and gtin13 now accept a string or an array of strings (regional packaging, re-releases); category now accepts the display string, a Schema.org CategoryCode object, or a mixed array of both. The pagefront:Document role enum gains repairability_index, recall_notice, and declaration_of_conformity; the pagefront:RelatedProduct relationship enum gains service. v0.8 also adds two GPSR-driven safety fields: a pagefront:safetyWarning[] array for typed, language-scoped safety warnings (text required; optional pictogram URL and open-vocabulary hazardCategory) and a pagefront:safetyNotice[] array for structured recall/safety notices (closed noticeType enum: recall, warning; closed remedy enum: repair, replacement, refund). v0.7 sheets remain valid under v0.8 once their format_version is updated. Validates the envelope and pagefront-namespaced extensions strictly; Schema.org-typed blocks permit additional unspecified properties.",
     "type": "object",
     "required": [
         "format_version",
@@ -433,6 +433,31 @@ export const PRODUCT_SCHEMA = {
             },
             "additionalProperties": true
         },
+        "amount": {
+            "description": "A currency amount: a JSON number, or a decimal string with a dot as decimal point, no thousands separators and no currency symbol. A Sheet uses one of the two carriers for all its amounts.",
+            "oneOf": [
+                {
+                    "type": "number"
+                },
+                {
+                    "type": "string",
+                    "pattern": "^-?\\d+(\\.\\d+)?$"
+                }
+            ]
+        },
+        "nonNegativeAmount": {
+            "description": "An amount that is zero or positive: the same two carriers as amount, with no leading minus. Used for prices, price bounds, base prices, price hints and discount amounts; only modifiers and adjustment amounts are signed.",
+            "oneOf": [
+                {
+                    "type": "number",
+                    "minimum": 0
+                },
+                {
+                    "type": "string",
+                    "pattern": "^\\d+(\\.\\d+)?$"
+                }
+            ]
+        },
         "variantEntry": {
             "type": "object",
             "required": [
@@ -482,10 +507,7 @@ export const PRODUCT_SCHEMA = {
                     "type": "string"
                 },
                 "price": {
-                    "type": [
-                        "string",
-                        "number"
-                    ]
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "image": {
                     "type": "string",
@@ -1181,7 +1203,7 @@ export const PRODUCT_SCHEMA = {
                     "type": "object"
                 },
                 "price": {
-                    "type": "string"
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "priceCurrency": {
                     "type": "string",
@@ -1301,10 +1323,10 @@ export const PRODUCT_SCHEMA = {
                     "type": "string"
                 },
                 "lowPrice": {
-                    "type": "number"
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "highPrice": {
-                    "type": "number"
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "priceCurrency": {
                     "type": "string",
@@ -1734,6 +1756,18 @@ export const PRODUCT_SCHEMA = {
                     "type": "boolean",
                     "default": true
                 },
+                "inputType": {
+                    "type": "string",
+                    "enum": [
+                        "select",
+                        "text"
+                    ],
+                    "default": "select"
+                },
+                "maxLength": {
+                    "type": "integer",
+                    "minimum": 1
+                },
                 "system": {
                     "type": "string"
                 },
@@ -1792,16 +1826,14 @@ export const PRODUCT_SCHEMA = {
                     "$ref": "#/$defs/configurationSelection"
                 },
                 "basePrice": {
-                    "type": "string",
-                    "pattern": "^[0-9]+(\\.[0-9]+)?$"
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "modifiers": {
                     "type": "object",
                     "additionalProperties": {
                         "type": "object",
                         "additionalProperties": {
-                            "type": "string",
-                            "pattern": "^-?[0-9]+(\\.[0-9]+)?$"
+                            "$ref": "#/$defs/amount"
                         }
                     }
                 },
@@ -1820,8 +1852,7 @@ export const PRODUCT_SCHEMA = {
                                 "minProperties": 1
                             },
                             "priceModifier": {
-                                "type": "string",
-                                "pattern": "^-?[0-9]+(\\.[0-9]+)?$"
+                                "$ref": "#/$defs/amount"
                             }
                         },
                         "additionalProperties": false
@@ -1955,7 +1986,7 @@ export const PRODUCT_SCHEMA = {
                     "maximum": 100
                 },
                 "discountAmount": {
-                    "type": "string"
+                    "$ref": "#/$defs/nonNegativeAmount"
                 },
                 "discountCurrency": {
                     "type": "string",

package/dist/rules/configurator-pricing.d.ts

@@ -38,9 +38,23 @@ export interface Dimension {
     name: string;
     /** `affectsPrice` is not `false`. */
     priced: boolean;
-    /** Option keys in document order; null when the dimension enumerates none. */
+    /** `inputType` is `text` (Definitions: *text dimension*). */
+    text: boolean;
+    /** The declared sizing `system`, when the dimension is a sizing dimension. */
+    system: string | undefined;
+    /**
+     * Option keys in document order; null when the dimension enumerates
+     * none. Always null for a text dimension, which takes free input.
+     */
     optionKeys: string[] | null;
 }
+/**
+ * `system` → the `pagefront:SizeAdjustment.sizeSystem` naming the same
+ * system (Definitions: *corresponding size system*).
+ */
+export declare const CORRESPONDING_SIZE_SYSTEM: Record<string, string>;
+/** The one modifier key of a text dimension: any non-empty input. */
+export declare const TEXT_KEY = "*";
 export interface Configurator {
     id: string | undefined;
     dimensions: Dimension[];
@@ -86,6 +100,9 @@ export declare function baseConfigurationProblems(configurator: Configurator, bl
 export type MissingModifierProblem = {
     kind: "no-options";
     dimension: string;
+} | {
+    kind: "no-text-modifier";
+    dimension: string;
 } | {
     kind: "missing";
     dimension: string;
@@ -108,7 +125,9 @@ export interface Band {
  * enumerated together. Every other priced dimension contributes its
  * smallest modifier to the minimum and its largest to the maximum,
  * independently of the rest, which yields the same band as the full
- * enumeration.
+ * enumeration. A priced text dimension is empty or non-empty: its `*`
+ * modifier lowers the minimum when negative and raises the maximum
+ * when positive.
  */
 export declare function computeBand(configurator: Configurator, block: Obj): Band | null;
 export {};

package/dist/rules/configurator-pricing.js

@@ -83,6 +83,18 @@ export function optionKey(value) {
         return JSON.stringify(value);
     return undefined;
 }
+/**
+ * `system` → the `pagefront:SizeAdjustment.sizeSystem` naming the same
+ * system (Definitions: *corresponding size system*).
+ */
+export const CORRESPONDING_SIZE_SYSTEM = {
+    UK: "WearableSizeSystemUK",
+    EU: "WearableSizeSystemEU",
+    US: "WearableSizeSystemUS",
+    JP: "WearableSizeSystemJP",
+};
+/** The one modifier key of a text dimension: any non-empty input. */
+export const TEXT_KEY = "*";
 function selection(value) {
     const obj = asObject(value);
     if (obj === null)
@@ -107,8 +119,9 @@ export function readConfigurator(sheet) {
         const d = asObject(entry);
         if (d === null || typeof d["name"] !== "string")
             continue;
+        const text = d["inputType"] === "text";
         let optionKeys = null;
-        if (Array.isArray(d["options"]) && d["options"].length > 0) {
+        if (!text && Array.isArray(d["options"]) && d["options"].length > 0) {
             optionKeys = [];
             for (const option of d["options"]) {
                 const key = optionKey(asObject(option)?.["value"]);
@@ -116,7 +129,13 @@ export function readConfigurator(sheet) {
                     optionKeys.push(key);
             }
         }
-        const dimension = { name: d["name"], priced: d["affectsPrice"] !== false, optionKeys };
+        const dimension = {
+            name: d["name"],
+            priced: d["affectsPrice"] !== false,
+            text,
+            system: typeof d["system"] === "string" ? d["system"] : undefined,
+            optionKeys,
+        };
         dimensions.push(dimension);
         if (!byName.has(dimension.name))
             byName.set(dimension.name, dimension);
@@ -213,11 +232,17 @@ export function missingModifierProblems(configurator, block) {
     for (const d of configurator.dimensions) {
         if (!d.priced)
             continue;
+        const entry = asObject(own(modifiers, d.name));
+        if (d.text) {
+            if (own(entry, TEXT_KEY) === undefined) {
+                problems.push({ kind: "no-text-modifier", dimension: d.name });
+            }
+            continue;
+        }
         if (d.optionKeys === null) {
             problems.push({ kind: "no-options", dimension: d.name });
             continue;
         }
-        const entry = asObject(own(modifiers, d.name));
         for (const option of d.optionKeys) {
             if (own(entry, option) === undefined) {
                 problems.push({ kind: "missing", dimension: d.name, option });
@@ -244,7 +269,9 @@ function matches(pairs, configuration) {
  * enumerated together. Every other priced dimension contributes its
  * smallest modifier to the minimum and its largest to the maximum,
  * independently of the rest, which yields the same band as the full
- * enumeration.
+ * enumeration. A priced text dimension is empty or non-empty: its `*`
+ * modifier lowers the minimum when negative and raises the maximum
+ * when positive.
  */
 export function computeBand(configurator, block) {
     const base = parseDecimal(block["basePrice"]);
@@ -279,8 +306,17 @@ export function computeBand(configurator, block) {
             continue;
         seen.add(d.name);
         if (d.optionKeys === null) {
-            if (d.priced)
+            if (!d.priced)
+                continue;
+            if (!d.text)
+                return null;
+            const amount = modifierOf(d, TEXT_KEY);
+            if (amount === undefined)
                 return null;
+            if (amount.units < 0n)
+                min = addDecimal(min, amount);
+            else
+                max = addDecimal(max, amount);
             continue;
         }
         if (coupledNames.has(d.name)) {

package/dist/rules/pdp-e-008.js

@@ -35,7 +35,7 @@ export const pdpE008 = {
         return hits.length > 0 ? hits : null;
     },
     messageTemplate: "Modifier for base option `{option}` of `{dimension}` at `{path}` is `{modifier}`; the base option's modifier is `0`.",
-    remediation: "Set the base option's modifier to `\"0\"` and express the other options of the dimension as differences from it. If the modifier is right, `basePrice` is the total of another configuration: correct `baseConfiguration` or `basePrice`.",
+    remediation: "Set the base option's modifier to zero and express the other options of the dimension as differences from it. If the modifier is right, `basePrice` is the total of another configuration: correct `baseConfiguration` or `basePrice`.",
     introduced: "v0.9 (2026-10-01 revision)",
     specReference: "product.md#configurator-pricing-and-price-bands",
 };

package/dist/rules/pdp-e-009.d.ts

@@ -7,6 +7,6 @@ import type { Rule } from "@pagefront/lint-core";
  * A `modifiers` key naming no dimension, or a dimension declared
  * `affectsPrice: false`, fires once at that key; under a priced
  * dimension, each option key that is not one of its options fires at
- * its own path.
+ * its own path. Under a priced text dimension, `*` is the one valid key.
  */
 export declare const pdpE009: Rule;

package/dist/rules/pdp-e-009.js

@@ -1,4 +1,4 @@
-import { asObject, resolveConfigurator, seg } from "./configurator-pricing.js";
+import { asObject, resolveConfigurator, seg, TEXT_KEY } from "./configurator-pricing.js";
 /**
  * PDP-E-009 — Modifier for an unknown dimension or option.
  * Transcribed from commerce/spec/rules.md (normative).
@@ -7,7 +7,7 @@ import { asObject, resolveConfigurator, seg } from "./configurator-pricing.js";
  * A `modifiers` key naming no dimension, or a dimension declared
  * `affectsPrice: false`, fires once at that key; under a priced
  * dimension, each option key that is not one of its options fires at
- * its own path.
+ * its own path. Under a priced text dimension, `*` is the one valid key.
  */
 export const pdpE009 = {
     id: "PDP-E-009",
@@ -41,7 +41,7 @@ export const pdpE009 = {
                 continue;
             }
             for (const option of Object.keys(asObject(entry) ?? {})) {
-                if (d.optionKeys !== null && d.optionKeys.includes(option))
+                if (d.text ? option === TEXT_KEY : d.optionKeys !== null && d.optionKeys.includes(option))
                     continue;
                 hits.push({
                     path: `${path}${seg(option)}`,

package/dist/rules/pdp-e-013.d.ts

@@ -0,0 +1,9 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-013 — Text dimension with options.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on a dimension whose `inputType` is `text` and whose `options`
+ * is an array with at least one entry.
+ */
+export declare const pdpE013: Rule;

package/dist/rules/pdp-e-013.js

@@ -0,0 +1,26 @@
+import { asObject } from "./configurator-pricing.js";
+/**
+ * PDP-E-013 — Text dimension with options.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires on a dimension whose `inputType` is `text` and whose `options`
+ * is an array with at least one entry.
+ */
+export const pdpE013 = {
+    id: "PDP-E-013",
+    title: "Text dimension with options",
+    severity: "error",
+    target: "$.data['pagefront:configurator'].dimensions[*]",
+    check: (match) => {
+        const d = asObject(match.value);
+        if (d === null || d["inputType"] !== "text")
+            return null;
+        if (!Array.isArray(d["options"]) || d["options"].length === 0)
+            return null;
+        return { values: { dimension: typeof d["name"] === "string" ? d["name"] : "(unnamed)" } };
+    },
+    messageTemplate: "Dimension `{dimension}` at `{path}` declares `inputType: \"text\"` and enumerates options.",
+    remediation: "Remove `options` from a free-text dimension, or remove `inputType: \"text\"` from a dimension the buyer picks a value in.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#configurator-pricing-and-price-bands",
+};

package/dist/rules/pdp-e-014.d.ts

@@ -0,0 +1,11 @@
+import type { Rule } from "@pagefront/lint-core";
+/**
+ * PDP-E-014 — Size advice in another system than the sizing dimension.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the adjustment carries a `sizeSystem`, the configurator has
+ * a sizing dimension in `UK`, `EU`, `US` or `JP`, and the adjustment's
+ * system corresponds to none of them. The `https://schema.org/` prefix
+ * on `sizeSystem` is accepted.
+ */
+export declare const pdpE014: Rule;

package/dist/rules/pdp-e-014.js

@@ -0,0 +1,34 @@
+import { asObject, CORRESPONDING_SIZE_SYSTEM, readConfigurator } from "./configurator-pricing.js";
+/**
+ * PDP-E-014 — Size advice in another system than the sizing dimension.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Fires when the adjustment carries a `sizeSystem`, the configurator has
+ * a sizing dimension in `UK`, `EU`, `US` or `JP`, and the adjustment's
+ * system corresponds to none of them. The `https://schema.org/` prefix
+ * on `sizeSystem` is accepted.
+ */
+export const pdpE014 = {
+    id: "PDP-E-014",
+    title: "Size advice in another system than the sizing dimension",
+    severity: "error",
+    target: "$.data['pagefront:sizeRecommendation'].sizeAdjustment",
+    check: (match, ctx) => {
+        const sizeSystem = asObject(match.value)?.["sizeSystem"];
+        if (typeof sizeSystem !== "string")
+            return null;
+        const systems = (readConfigurator(ctx.sheet)?.dimensions ?? [])
+            .map((d) => d.system)
+            .filter((s) => s !== undefined && Object.hasOwn(CORRESPONDING_SIZE_SYSTEM, s));
+        if (systems.length === 0)
+            return null;
+        const bare = sizeSystem.replace(/^https?:\/\/schema\.org\//, "");
+        if (systems.some((s) => CORRESPONDING_SIZE_SYSTEM[s] === bare))
+            return null;
+        return { values: { sizeSystem, dimensionSystem: systems[0] } };
+    },
+    messageTemplate: "Size adjustment at `{path}` is in `{sizeSystem}` but the Sheet's sizing dimension is in `{dimensionSystem}`.",
+    remediation: "State the adjustment in the sizing dimension's system if the merchant states it there. If the merchant's advice is in another system, remove `sizeAdjustment` and keep the merchant's wording in `description`.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#size-guidance-pagefrontsizechart-and-pagefrontsizerecommendation",
+};

package/dist/rules/pdp-e-015.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "@pagefront/lint-core";
+export declare const pdpE015: Rule;

package/dist/rules/pdp-e-015.js

@@ -0,0 +1,91 @@
+import { asObject, seg } from "./configurator-pricing.js";
+/**
+ * PDP-E-015 — Amounts mix numbers and strings.
+ * Transcribed from commerce/spec/rules.md (normative).
+ *
+ * Walks `data` in document order over the catalogue's closed list of
+ * amount fields and fires once per Sheet when at least one amount is a
+ * JSON number and at least one is a string. `numberPath` and
+ * `stringPath` are the first amount of each carrier.
+ */
+const OFFER_FIELDS = ["price", "lowPrice", "highPrice"];
+const SPECIFICATION_FIELDS = ["price", "minPrice", "maxPrice"];
+const MONETARY_FIELDS = ["value", "minValue", "maxValue"];
+const ROLE_OF_KEY = {
+    offers: "offer",
+    priceSpecification: "specification",
+    hasVariant: "variant",
+    "pagefront:promotions": "promotion",
+    "pagefront:configuratorPricing": "pricing",
+};
+function record(found, value, path) {
+    if (typeof value === "number")
+        found.numberPath ??= path;
+    else if (typeof value === "string")
+        found.stringPath ??= path;
+}
+function amountFields(node, role) {
+    const fields = [];
+    if (role === "offer")
+        fields.push(...OFFER_FIELDS);
+    if (role === "specification")
+        fields.push(...SPECIFICATION_FIELDS);
+    if (role === "variant")
+        fields.push("price");
+    if (role === "promotion")
+        fields.push("discountAmount");
+    if (role === "pricing")
+        fields.push("basePrice");
+    if (role === "adjustment")
+        fields.push("priceModifier");
+    if (node["@type"] === "MonetaryAmount")
+        fields.push(...MONETARY_FIELDS);
+    return fields;
+}
+function walk(node, path, role, found) {
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => walk(item, `${path}[${index}]`, role, found));
+        return;
+    }
+    const obj = asObject(node);
+    if (obj === null)
+        return;
+    const fields = amountFields(obj, role);
+    for (const [key, value] of Object.entries(obj)) {
+        const childPath = `${path}${seg(key)}`;
+        if (fields.includes(key)) {
+            record(found, value, childPath);
+            continue;
+        }
+        if (role === "modifiers") {
+            // one entry per dimension; every value under it is an amount
+            for (const [option, amount] of Object.entries(asObject(value) ?? {})) {
+                record(found, amount, `${childPath}${seg(option)}`);
+            }
+            continue;
+        }
+        let childRole = ROLE_OF_KEY[key];
+        if (role === "pricing" && key === "modifiers")
+            childRole = "modifiers";
+        if (role === "pricing" && key === "adjustments")
+            childRole = "adjustment";
+        walk(value, childPath, childRole, found);
+    }
+}
+export const pdpE015 = {
+    id: "PDP-E-015",
+    title: "Amounts mix numbers and strings",
+    severity: "error",
+    target: "$.data",
+    check: (match) => {
+        const found = {};
+        walk(match.value, match.path, undefined, found);
+        if (found.numberPath === undefined || found.stringPath === undefined)
+            return null;
+        return { values: { numberPath: found.numberPath, stringPath: found.stringPath } };
+    },
+    messageTemplate: "Amounts mix numbers and strings; use one carrier throughout the Sheet.",
+    remediation: "Carry every amount the same way. Decimal strings are recommended when amounts have fractional parts.",
+    introduced: "v0.9 (2026-10-01 revision)",
+    specReference: "product.md#amounts",
+};

package/dist/rules/pdp-w-032.d.ts

@@ -4,7 +4,8 @@ import type { Rule } from "@pagefront/lint-core";
  * Transcribed from commerce/spec/rules.md (normative).
  *
  * Applies to a resolving pricing block whose `pricing` is absent or
- * `complete`. One finding per priced option with no modifier, and one
- * per priced dimension that enumerates no options, all at the block.
+ * `complete`. One finding per priced option with no modifier, one per
+ * priced text dimension with no `*` modifier, and one per priced select
+ * dimension that enumerates no options, all at the block.
  */
 export declare const pdpW032: Rule;