@pagefront/lint-commerce 0.12.1 → 0.14.0

package/dist/sheet-type.d.ts

@@ -1,20 +1,25 @@
 import type { Sheet } from "@pagefront/lint-core";
 /**
- * Sheet-type detection for page-type dispatch: organization sheets are
- * a different page type from product sheets, and each page type's
- * rules must never run on the other's sheets.
+ * Sheet-type detection for page-type dispatch: product sheets,
+ * organization sheets and collection sheets are three page types, and
+ * each page type's rules must never run on another's sheets.
  *
  * The envelope `$schema` is authoritative when it names a page type:
- * `/spec/commerce/organization/` or `/spec/commerce/product/` in its
- * path, or the `/schemas/organization/` and `/schemas/product/` paths
- * the schemas were identified by before 2026-09-08. The
- * data-block fallback — `@type` of `Organization` / `OnlineStore` /
- * `OnlineBusiness` with `pagefront:commerceRole` present — applies
- * only when `$schema` is absent or names neither, so a declared schema
- * always wins over shape heuristics. The default is `product`, the
- * page type the catalogue predates dispatch with.
+ * `/spec/commerce/organization/`, `/spec/commerce/product/` or
+ * `/spec/commerce/collection/` in its path, or the
+ * `/schemas/organization/` and `/schemas/product/` paths the schemas
+ * were identified by before 2026-09-08 (the collection schema never
+ * had such a path). The data-block fallbacks — `@type` of
+ * `Organization` / `OnlineStore` / `OnlineBusiness` with
+ * `pagefront:commerceRole` present, and `@type` of `Collection` with
+ * `pagefront:collectionKind` present — apply only when `$schema` is
+ * absent or names no type, so a declared schema always wins over shape
+ * heuristics. The default is `product`, the page type the catalogue
+ * predates dispatch with.
  */
-export type SheetType = "product" | "organization";
+export type SheetType = "product" | "organization" | "collection";
+/** The sheet types as the rule messages name them. */
+export declare const SHEET_LABEL: Record<SheetType, string>;
 /**
  * The two lines a sheet can belong to. A sheet on the *release* line
  * carries `release` and validates against the current sheet-spec

package/dist/sheet-type.js

@@ -1,3 +1,9 @@
+/** The sheet types as the rule messages name them. */
+export const SHEET_LABEL = {
+    product: "Product Sheet",
+    organization: "Organization Sheet",
+    collection: "Collection Sheet",
+};
 /** The legacy line's `$schema` version segment: two parts, `v0.9.json`. */
 const LEGACY_SCHEMA_SEGMENT = /\/v\d+\.\d+\.json$/;
 /**
@@ -31,6 +37,8 @@ export function detectSheetType(sheet) {
             return "organization";
         if (schema.includes("/spec/commerce/product/"))
             return "product";
+        if (schema.includes("/spec/commerce/collection/"))
+            return "collection";
         if (schema.includes("/schemas/organization/"))
             return "organization";
         if (schema.includes("/schemas/product/"))
@@ -44,6 +52,9 @@ export function detectSheetType(sheet) {
             d["pagefront:commerceRole"] !== undefined) {
             return "organization";
         }
+        if (d["@type"] === "Collection" && d["pagefront:collectionKind"] !== undefined) {
+            return "collection";
+        }
     }
     return "product";
 }

package/dist/test-hooks.d.ts

@@ -0,0 +1,15 @@
+import { type ReleaseManifestShape } from "./overrides.js";
+export interface TestManifestOptions {
+    /** The manifest to read in place of the bundled one. */
+    manifest: ReleaseManifestShape;
+    /**
+     * Schemas to validate against at Layer 1 for ids the package does not
+     * bundle, keyed by `$id`; compiled here with the options the build
+     * uses for the frozen schemas.
+     */
+    schemas?: Record<string, object>;
+}
+/** Install a test manifest (and optional schemas) until `clearTestManifest`. */
+export declare function installTestManifest(options: TestManifestOptions): void;
+/** Back to the bundled manifest and the compiled validators. */
+export declare function clearTestManifest(): void;

package/dist/test-hooks.js

@@ -0,0 +1,28 @@
+/**
+ * Test-only hooks. Not part of the public surface (index.ts does not
+ * export this module): the conformance suite and the collection tests
+ * import it from dist/ to run the linter against a release manifest
+ * other than the bundled commerce/spec/releases.json, and to validate
+ * at Layer 1 against an editable schema head the frozen store does not
+ * carry yet. Production callers never reach this code, and nothing here
+ * imports a Node built-in, so the library stays browser-pure.
+ */
+import Ajv2020Module from "ajv/dist/2020.js";
+import addFormatsModule from "ajv-formats";
+import { setOverrides } from "./overrides.js";
+const Ajv2020 = (Ajv2020Module.default ?? Ajv2020Module);
+const addFormats = (addFormatsModule.default ?? addFormatsModule);
+/** Install a test manifest (and optional schemas) until `clearTestManifest`. */
+export function installTestManifest(options) {
+    const ajv = new Ajv2020({ allErrors: true, allowUnionTypes: true });
+    addFormats(ajv);
+    const validators = {};
+    for (const [id, schema] of Object.entries(options.schemas ?? {})) {
+        validators[id] = ajv.compile(schema);
+    }
+    setOverrides({ manifest: options.manifest, validators });
+}
+/** Back to the bundled manifest and the compiled validators. */
+export function clearTestManifest() {
+    setOverrides({});
+}

package/dist/validate-and-lint.d.ts

@@ -5,7 +5,7 @@
  * boundary: callers see `SchemaError`, never Ajv's own error type.
  */
 import type { LintOptions, Report } from "@pagefront/lint-core";
-import type { SheetType } from "./sheet-type.js";
+import { type SheetType } from "./sheet-type.js";
 /**
  * One Layer 1 (JSON Schema) validation failure, in a shape this
  * package owns. `instancePath` is a JSON Pointer to the offending
@@ -30,9 +30,12 @@ export type ValidateAndLintResult = {
  * sheet is validated against the schema its `$schema` names. Returns
  * the errors, empty when the document is valid. A `release` the
  * manifest does not list is a Layer 1 failure of its own, reported at
- * `/release` with the keyword `release`; a legacy `$schema` naming no
- * bundled schema is reported at `/$schema`. In neither case is the
- * document validated against some other version.
+ * `/release` with the keyword `release`, and so is a release that
+ * bundles no schema for the sheet's type (a type that joined the line
+ * later); a legacy `$schema` naming no bundled schema is reported at
+ * `/$schema`, and a legacy sheet of a type that was never on that line
+ * at `/format_version`. In no case is the document validated against
+ * some other version.
  */
 export declare function schemaErrorsFor(input: unknown, sheetType?: SheetType): SchemaError[];
 /**
@@ -53,6 +56,7 @@ export declare function schemaErrorsFor(input: unknown, sheetType?: SheetType):
  *
  * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
  * lint with the product catalogue, Commerce Organization Sheets with
- * the organization catalogue.
+ * the organization catalogue, Commerce Collection Sheets with the
+ * collection catalogue.
  */
 export declare function validateAndLint(input: unknown, options?: LintOptions): ValidateAndLintResult;

package/dist/validate-and-lint.js

@@ -1,5 +1,7 @@
 import { lintSheet } from "./lint-sheet.js";
+import { overrides } from "./overrides.js";
 import { resolveSchema } from "./schema-registry.js";
+import { SHEET_LABEL } from "./sheet-type.js";
 import { VALIDATORS } from "./schema-validators.js";
 // The validators are compiled ahead of time (see schema-validators.d.ts):
 // nothing here generates code at load time, so the pipeline runs where
@@ -11,9 +13,12 @@ import { VALIDATORS } from "./schema-validators.js";
  * sheet is validated against the schema its `$schema` names. Returns
  * the errors, empty when the document is valid. A `release` the
  * manifest does not list is a Layer 1 failure of its own, reported at
- * `/release` with the keyword `release`; a legacy `$schema` naming no
- * bundled schema is reported at `/$schema`. In neither case is the
- * document validated against some other version.
+ * `/release` with the keyword `release`, and so is a release that
+ * bundles no schema for the sheet's type (a type that joined the line
+ * later); a legacy `$schema` naming no bundled schema is reported at
+ * `/$schema`, and a legacy sheet of a type that was never on that line
+ * at `/format_version`. In no case is the document validated against
+ * some other version.
  */
 export function schemaErrorsFor(input, sheetType) {
     const envelope = (typeof input === "object" && input !== null ? input : {});
@@ -36,7 +41,29 @@ export function schemaErrorsFor(input, sheetType) {
             },
         ];
     }
-    const validate = VALIDATORS[resolution.id];
+    if (resolution.kind === "unbundled-type") {
+        const label = SHEET_LABEL[resolution.sheetType];
+        return [
+            resolution.release === null
+                ? {
+                    instancePath: "/format_version",
+                    message: `the legacy draft line has no ${label} schema`,
+                    keyword: "format_version",
+                }
+                : {
+                    instancePath: "/release",
+                    message: `release ${resolution.release} bundles no ${label} schema`,
+                    keyword: "release",
+                },
+        ];
+    }
+    // A test may install a validator for a schema the store does not
+    // carry yet (test-hooks.ts); the compiled validators are the rule.
+    const validate = overrides().validators?.[resolution.id] ?? VALIDATORS[resolution.id];
+    if (validate === undefined) {
+        // Unreachable when the store and the manifest agree, which CI checks.
+        return [{ instancePath: "/release", message: `no schema bundled for ${resolution.id}`, keyword: "release" }];
+    }
     if (validate(input))
         return [];
     return (validate.errors ?? []).map((error) => ({
@@ -63,7 +90,8 @@ export function schemaErrorsFor(input, sheetType) {
  *
  * Layer 2 dispatches by page type (see sheet-type.ts): product sheets
  * lint with the product catalogue, Commerce Organization Sheets with
- * the organization catalogue.
+ * the organization catalogue, Commerce Collection Sheets with the
+ * collection catalogue.
  */
 export function validateAndLint(input, options) {
     const schemaErrors = schemaErrorsFor(input);

package/dist/version.d.ts

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export declare const PACKAGE_VERSION = "0.12.1";
+export declare const PACKAGE_VERSION = "0.14.0";

package/dist/version.js

@@ -5,4 +5,4 @@
  * (test/linter-version.test.mjs) fails when they diverge. Regenerate
  * on version bump.
  */
-export const PACKAGE_VERSION = "0.12.1";
+export const PACKAGE_VERSION = "0.14.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pagefront/lint-commerce",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Pagefront commerce linter: the commerce rule catalogue and CLI, on the @pagefront/lint-core engine.",
   "license": "Apache-2.0",
   "repository": {
@@ -39,7 +39,7 @@
     "prepublishOnly": "npm test"
   },
   "dependencies": {
-    "@pagefront/lint-core": "^0.3.0",
+    "@pagefront/lint-core": "^0.4.0",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1"
   },