@curly-message/conformance 1.0.0-next.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 G.A.W.Group, s.r.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,266 @@
+# @curly-message/conformance
+
+The conformance set of the [Curly Message Format](../SPEC.md): fixtures that
+an implementation in any language is measured against, and a JavaScript runner
+that drives one through the adapter of section 14.3.
+
+A fixture is a resolution written out — the inputs section 4 lists, and the
+output and the reports they must produce. The set is derived from the
+specification, and each case names the section it pins, so a failure points at
+the sentence the implementation disagrees with.
+
+```json
+{
+  "id": "fallback/payload-outranks-inline",
+  "section": "10",
+  "description": "The payload's own default takes precedence over the inline one.",
+  "message": "Hello, {{name; default:Guest;}}!",
+  "payload": { "default": "Friend" },
+  "expected": { "output": "Hello, Friend!" }
+}
+```
+
+## Status
+
+**Unpublished.** The set lives in the specification's repository because its
+fixtures are artifacts of the format, not of any one implementation, and it is
+versioned against the specification: version 1 of the set targets version 1 of
+the format. Until it is published, an implementation is assessed against the
+document alone (section 2).
+
+## The fixture files
+
+`fixtures/*.json` groups the cases by the section of the specification they
+pin, one file per group, and `index.json` lists the files with the level and
+section each covers. `schema/fixture.schema.json` is the JSON Schema every file
+validates against, so a runner in another language checks the set before it
+reads it.
+
+A file has a `format`, the versioned identifier of the format it targets; a
+`level`, the conformance level of section 2 that requires every case in it;
+a `section`, the heading of the specification the file pins; and its `cases`.
+
+A case is either written out or generated. A written-out case has:
+
+| Field | Meaning |
+| --- | --- |
+| `id` | Unique across the set: the file's group, a slash, and a slug. |
+| `description` | One sentence naming what the case pins, for the failure it would print. |
+| `section` | A more specific heading than the file's, where the case pins one. |
+| `message` | The message. Usually text; any other JSON value is a message a host wrote as something else (section 4), and the `undefined` tag below is a message the caller did not supply (section 10). |
+| `payload` | The payload (section 3). Entries hold values, wrappers (section 4.1) or tagged values. |
+| `props` | The caller's formatting properties, grouped by modifier name (section 11.2). |
+| `locale` | The locale. |
+| `key` | The message's key (section 4). Any JSON value: a key a host wrote as something other than text is echoed as the text it converts to (section 10). |
+| `modifiers` | Host-defined modifiers to register (section 11.3): a name to a behaviour from the catalogue below. |
+| `defaults` | The implementation-configured defaults, the bottom formatting layer of section 11.2, grouped by modifier name. |
+| `expected` | What the resolution must produce: an `output`, or for a locale-dependent one a `format` request; and the `reports`, in the order they are emitted, none where the field is omitted. |
+
+A generated case has an `id`, a `description`, optionally a `section`, and a
+`generate` naming one of the constructions under *Generated cases* below. The
+runner builds its inputs and its expectation from the limits the adapter
+declares.
+
+### Tagged values
+
+A fixture is JSON, and the format takes inputs JSON cannot spell. Three tagged
+objects stand in for them, anywhere in a message, a payload, props, a key or
+the defaults. A runner decodes each into the host value it names before the
+adapter sees it; nothing else is decoded, so a payload entry of any other shape
+reaches the implementation as the plain data JSON describes.
+
+| Tag | Stands for |
+| --- | --- |
+| `{ "$curly": "undefined" }` | The host's undefined (sections 4.1, 9.2, 10). A message so tagged is one the caller did not supply. |
+| `{ "$curly": "unserializable" }` | A value that no conversion can describe (section 4). The JavaScript runner builds a plain object that references itself. |
+| `{ "$curly": "nodes", "count": N }` | A value whose serialization visits at least `N` nodes (section 13). The runner builds a tree of shared references — each level an array naming the level below twice — deep enough to visit `N`. |
+
+### Host-defined modifiers
+
+A case at the Extensions level may register modifiers. It cannot ship code, so
+it names behaviours from a catalogue every runner implements in its own
+language and hands to the adapter as functions of section 11's inputs: the
+value and the default as text, the options as the placeholder wrote them, the
+props composed under the modifier's own name, and the locale where one is
+available. The adapter wraps each into its implementation's own modifier
+signature.
+
+| Behaviour | Answers with |
+| --- | --- |
+| `upper` | The value with its ASCII letters uppercased. |
+| `echo` | The value, unchanged. |
+| `empty` | The empty string — an answer, not the absence of one. |
+| `nothing` | The host's nothing: no answer, so the placeholder takes the fallback chain (section 11). |
+| `raise` | Nothing; it raises, and the failure must be contained (section 11.3). |
+| `default` | The default, read through the chain (section 10). |
+| `options` | The options in the order they were handed over, each `key=value`, joined by commas: `a=A,b=,c=c` (section 9.4). |
+| `props` | The props it received, each own property `name=value` with the value as JSON, sorted by name and joined by commas: `maximumFractionDigits=1,useGrouping=true` (sections 11.2, 11.3). |
+| `locale` | The locale it received, or `none` where it received none. |
+| `object` | A plain object holding the value under `answer`, so the answer serializes (section 11): `{"answer":"X"}`. |
+
+### Locale-dependent expectations
+
+The formatting modifiers of section 11.2 delegate to the host's
+internationalization facilities, whose output varies with the host's locale
+data. A case for one therefore states the formatting request rather than its
+result: which facility, the options it is constructed with, and the input the
+modifier hands it. The options are the properties the facility reads, as the
+layers of section 11.2 compose them and the modifier pins them — `number`'s
+default maximum, `currency`'s style, `ago`'s `numeric` — and not the format's
+own `ratio` and `format`, which the input already reflects. The runner performs
+that request on the host it runs on and expects the implementation's output to
+match it, so the case pins what the specification pins — the request — and the
+locale data stays the host's.
+
+| `api` | `input` | The request |
+| --- | --- | --- |
+| `NumberFormat` | a number | `Intl.NumberFormat(locale, options).format(input)` |
+| `DateTimeFormat` | milliseconds since the epoch | `Intl.DateTimeFormat(locale, options).format(input)` |
+| `RelativeTimeFormat` | `[value, unit]` | `Intl.RelativeTimeFormat(locale, options).format(value, unit)` |
+
+The locale is the case's own. The message of such a case is the placeholder
+alone, so that the whole output is the request's result. A date case names a
+`timeZone` in its props, because a request without one formats in the host's,
+which the fixture cannot know.
+
+### Generated cases
+
+Section 13 lets an implementation permit more than its minima and requires it
+to document what it permits, so a case at a limit cannot be written out: it is
+built from the limits the adapter declares, and exercises the implementation at
+the bounds it documents. `P` is the declared pass limit, `L` the output limit,
+`C` the conversion limit, and every generated case reports through the key
+`limits`.
+
+| `generate` | Message and payload | Expected |
+| --- | --- | --- |
+| `passes-at-limit` | `{{p1}}`, with `p1` … `p<P-1>` each holding the placeholder of the next, and `p<P>` holding `settled`. Settling takes exactly `P` passes. | `settled`, no reports. |
+| `passes-over-limit` | The same chain one link longer: `p<P>` holds `{{p<P+1>}}` and `p<P+1>` holds `settled`. | `{{p<P+1>}}` — the last settled text, its placeholder unresolved — and one `pass-limit` report of origin `limit`. |
+| `output-at-limit` | `{{v}}`, with `v` holding `x` repeated `L` times. | That text, no reports. |
+| `output-over-limit` | `{{v}}`, with `v` holding `x` repeated `L + 1` times. | `{{v}}` — the pass was discarded whole, so the message as it reached the first pass is what settled — and one `output-limit` report of origin `limit`. |
+| `output-over-limit-stops` | `{{v}}{{w:raise}}`, with `v` as above, `w` holding `w`, and `raise` registered under that name. | `{{v}}{{w:raise}}` and one `output-limit` report: a placeholder past the limit is neither resolved nor reported, and the modifier it names is not called. This case is at the Extensions level. |
+| `conversion-over-limit` | `{{v; default:D}}`, with `v` a `nodes` value of `C + 1`. | `D` and one `unserializable-value` report of origin `payload`: a serialization that reaches the limit describes nothing, so the placeholder takes the chain. |
+
+An adapter whose reports carry a `limit` is held to the declared limit on the
+`pass-limit` and `output-limit` reports.
+
+## The adapter
+
+Section 14.3 has the conformance set observe an implementation through an
+adapter the implementation supplies. It is three things:
+
+```ts
+import type { Adapter } from '@curly-message/conformance';
+
+export const adapter: Adapter = {
+  levels: ['core', 'intl', 'extensions'],
+  limits: { passes: 10, output: 100000, conversion: 100000 },
+  resolve: ({ message, payload, props, locale, key, modifiers, defaults }) => {
+    // Call the implementation and answer with what it produced.
+    return { output, reports };
+  },
+};
+```
+
+`levels` is the statement section 2 requires: the levels the implementation
+satisfies. The runner selects the fixtures those levels require and skips the
+rest, and the skipped cases are listed, not hidden. `limits` is the statement
+section 13 requires, and is what the generated cases are built from.
+
+`resolve` is handed one resolution's inputs, decoded into host values, and
+answers with the `output` and the `reports` the implementation produced. The
+output is compared exactly. A report is compared by its `code`; its `origin`,
+`key` and `limit` are compared where the adapter's reports carry them, since
+the specification prescribes no shape for a report, only what a code names and
+which origin it declares. Reports are compared in order, because section 14.3
+has an implementation report in the pass where the condition was met and
+section 9 resolves a pass in source order. An adapter that leaves `reports`
+undefined says the implementation does not report at all — reporting is a
+SHOULD — and every expectation about reports is then skipped, and said to be:
+such a case passes on its output alone with an outcome of
+`{ ok: true, unobserved: 'reports' }`, `run` lists it under `unobserved`
+beside `passed`, and the command counts those cases in its summary.
+
+## Running the set
+
+From a test:
+
+```ts
+import { check, plan, run } from '@curly-message/conformance';
+
+check(adapter);          // throws with the list of failures, if any
+
+const result = run(adapter);   // { passed, failed, skipped, unobserved }
+
+for (const planned of plan(adapter).cases) {
+  test(planned.id, () => {
+    const outcome = planned.execute();
+
+    expect(outcome).toMatchObject({ ok: true });
+  });
+}
+```
+
+`plan` is for a test framework: one entry per case the adapter's levels
+require, each carrying its `id`, `file`, `level`, `section`, `description` and
+an `execute` that runs it and answers with an outcome — `{ ok: true }`, or the
+reason it failed beside what was expected and what came back. `run` executes a
+plan and sorts the outcomes. Both take options: `fixtures`, to run a set other
+than the shipped one, and `levels`, to run a subset of the levels the adapter
+claims. An adapter must claim `core`, and `levels` must name only levels it
+claims; anything else is an error rather than a skip. A case at a level that
+does not run is skipped with a reason naming the level, and so is
+`output-over-limit-stops` wherever `extensions` does not run, whatever the
+level of its file.
+
+The package also exports what those are built from: `fixtures()` reads the
+shipped set and `load(directory)` any directory of fixture files, both sorted
+by file name, which is what the `fixtures` option takes; `summarize(result)`
+renders what the command prints; and `decode` and `behaviours` are the tagged
+values and the catalogue as this runner implements them, for an adapter's own
+tests to reuse.
+
+From the command line, with a module that exports the adapter as `adapter` or
+as its default export:
+
+```bash
+npx curly-message-conformance ./adapter.mjs
+npx curly-message-conformance ./adapter.mjs --levels core,intl
+npx curly-message-conformance ./adapter.mjs --fixtures ./my-fixtures
+```
+
+The command prints one line per failure and a summary, and exits non-zero where
+anything failed. `--fixtures` points at a directory of fixture files, so a set
+under development runs against an implementation before it ships.
+
+## Writing a fixture
+
+A case pins a sentence of the specification, and states which: the `section`
+is what a failure points at. Its expectation follows from the text, not from
+what an implementation happens to do, so a behaviour the specification leaves
+to the host — how its numeric conversion reads a literal, which text its date
+parsing accepts, what a host type converts to — is not a case. Where the
+specification lets two conforming implementations differ, the set does not
+choose between them.
+
+The reference implementation is what the set is checked against before it
+lands, and the set is what the reference is checked against in turn. Where
+the two disagree, the specification decides which is wrong.
+
+`npm run manifest` regenerates `index.json` from the files; the tests fail
+where it is stale, where an `id` repeats, where a file does not validate
+against the schema, or where a `section` names no heading of `SPEC.md`.
+
+## Development
+
+```bash
+npm install
+npm test         # builds, typechecks, lints, then runs vitest
+npm run lint:fix # applies what the lint step only reports
+```
+
+Requires Node.js 22 or newer.
+
+## License
+
+[MIT](./LICENSE)

package/bin/conformance.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { parseArgs } from 'node:util';
+import { load, run, summarize } from '../dist/index.js';
+
+const USAGE = 'Usage: curly-message-conformance <adapter module> [--levels core,intl,extensions] [--fixtures <directory>]';
+
+const main = async () => {
+  const { positionals: [path, ...rest], values } = parseArgs({
+    allowPositionals: true,
+    options: { levels: { type: 'string' }, fixtures: { type: 'string' } },
+  });
+
+  if (!path || rest.length) throw new Error(USAGE);
+
+  const module = await import(pathToFileURL(resolve(path)).href);
+  const adapter = module.adapter ?? module.default;
+
+  if (!adapter) throw new Error(`${path} exports no adapter: export it as "adapter" or as the default export.`);
+
+  const result = run(adapter, {
+    ...(values.levels === undefined ? {} : { levels: values.levels.split(',') }),
+    ...(values.fixtures === undefined ? {} : { fixtures: load(resolve(values.fixtures)) }),
+  });
+
+  console.log(summarize(result));
+
+  return result.failed.length ? 1 : 0;
+};
+
+try {
+  process.exitCode = await main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 2;
+}

package/bin/manifest.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// Regenerates index.json from the fixture files. An output path may be given
+// to write the manifest elsewhere, which is how the tests compare the shipped
+// one with a fresh one.
+import { readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const root = fileURLToPath(new URL('..', import.meta.url));
+const directory = join(root, 'fixtures');
+
+const read = (path) => JSON.parse(readFileSync(path, 'utf8'));
+
+const { version } = read(join(root, 'package.json'));
+
+const files = readdirSync(directory).filter((name) => name.endsWith('.json')).sort().map((name) => {
+  const { level, section, cases } = read(join(directory, name));
+
+  return { path: `fixtures/${name}`, level, section, cases: cases.length };
+});
+
+const manifest = { format: 'curly-message-1', version, files };
+
+writeFileSync(process.argv[2] ?? join(root, 'index.json'), `${JSON.stringify(manifest, null, 2)}\n`);

package/dist/index.d.ts

@@ -0,0 +1,225 @@
+/**
+ * The contract between the conformance set and an implementation under test.
+ * Everything here is spelled in the vocabulary of the specification — the
+ * inputs of section 4, the levels of section 2, the limits of section 13, the
+ * report codes of section 14.2 — and nothing in it names a host or an
+ * implementation's own API. An implementation meets the set through an
+ * `Adapter` (section 14.3), which is where its own calling convention is
+ * translated into this one.
+ */
+/** A conformance level of section 2. */
+type Level = 'core' | 'intl' | 'extensions';
+/**
+ * The limits of section 13 an implementation permits, as it documents them:
+ * the passes it performs, the output it holds in the host's own string unit,
+ * and the nodes one conversion may visit. Section 13 states the minima.
+ */
+type Limits = {
+    passes: number;
+    output: number;
+    conversion: number;
+};
+/**
+ * What a host-defined modifier receives (sections 11, 11.3), as the
+ * specification lists it: the value and the default as text, the options as
+ * the placeholder wrote them, the props composed under the modifier's own
+ * name, and the locale where one is available. The default is read through a
+ * call, because section 10 walks the chain only where a modifier asks for it.
+ */
+type ModifierInput = {
+    value: string;
+    options: {
+        key: string;
+        value: string;
+    }[];
+    props: Record<string, unknown>;
+    locale?: string;
+    default: () => string;
+};
+/** A behaviour of the catalogue, as a function an adapter wraps into its own modifier signature. */
+type ModifierBehaviour = (input: ModifierInput) => unknown;
+/** The names of the catalogue's behaviours; README.md states each. */
+type Behaviour = 'upper' | 'echo' | 'empty' | 'nothing' | 'raise' | 'default' | 'options' | 'props' | 'locale' | 'object';
+/**
+ * One resolution's inputs, decoded into host values: the four inputs of
+ * section 4 and the key, plus the two pieces of configuration a case may ask
+ * for — host-defined modifiers to register (section 11.3) and the
+ * implementation-configured defaults of section 11.2.
+ */
+type Resolution = {
+    message: unknown;
+    payload?: unknown;
+    props?: unknown;
+    locale?: string;
+    key?: unknown;
+    modifiers?: Record<string, ModifierBehaviour>;
+    defaults?: unknown;
+};
+type ReportCode = 'unknown-modifier' | 'failed-modifier' | 'missing-options' | 'unserializable-value' | 'missing-locale' | 'pass-limit' | 'output-limit';
+type ReportOrigin = 'message' | 'payload' | 'limit';
+/**
+ * A report as the adapter observed it. Only the code is required; a field the
+ * adapter supplies is held to what the case expects of it, and one it leaves
+ * out is not checked, because section 14.3 prescribes no channel and no shape.
+ */
+type Report = {
+    code: ReportCode;
+    origin?: ReportOrigin;
+    key?: unknown;
+    limit?: number;
+};
+/**
+ * What a resolution produced. `reports` left undefined says the adapter does
+ * not observe reports at all, and every expectation about them is skipped.
+ */
+type Resolved = {
+    output: string;
+    reports?: Report[];
+};
+/**
+ * The adapter of section 14.3: what an implementation supplies so the set can
+ * drive it. `levels` selects the fixtures the set runs, and `limits` derives
+ * the cases that sit at a boundary, so both are the implementation's own
+ * statements about itself made observable.
+ */
+type Adapter = {
+    levels: readonly Level[];
+    limits: Limits;
+    resolve: (input: Resolution) => Resolved;
+};
+/** A section reference: a heading number of SPEC.md, such as `9.2` or `A.4`. */
+type Section = string;
+/** A formatting request whose result on the running host is the expected output. */
+type FormatRequest = {
+    api: 'NumberFormat' | 'DateTimeFormat' | 'RelativeTimeFormat';
+    options?: Record<string, unknown>;
+    input: unknown;
+};
+type ExpectedReport = {
+    code: ReportCode;
+    origin: ReportOrigin;
+    key?: unknown;
+};
+type Expected = {
+    output?: string;
+    format?: FormatRequest;
+    reports?: ExpectedReport[];
+};
+/** A case written out in a fixture file, its inputs still JSON: tagged values not yet decoded. */
+type ConcreteCase = {
+    id: string;
+    description: string;
+    section?: Section;
+    message: unknown;
+    payload?: Record<string, unknown>;
+    props?: Record<string, unknown>;
+    locale?: string;
+    key?: unknown;
+    modifiers?: Record<string, Behaviour>;
+    defaults?: Record<string, unknown>;
+    expected: Expected;
+};
+type Generator = 'passes-at-limit' | 'passes-over-limit' | 'output-at-limit' | 'output-over-limit' | 'output-over-limit-stops' | 'conversion-over-limit';
+/** A case the runner builds from the adapter's limits. */
+type GeneratedCase = {
+    id: string;
+    description: string;
+    section?: Section;
+    generate: Generator;
+};
+type Case = ConcreteCase | GeneratedCase;
+type FixtureFile = {
+    format: 'curly-message-1';
+    level: Level;
+    section: Section;
+    cases: Case[];
+};
+/** A fixture file together with the name it is shipped under. */
+type Fixture = {
+    name: string;
+    file: FixtureFile;
+};
+/** The manifest shipped as `index.json`. */
+type Manifest = {
+    format: 'curly-message-1';
+    version: string;
+    files: {
+        path: string;
+        level: Level;
+        section: Section;
+        cases: number;
+    }[];
+};
+type Failure = {
+    ok: false;
+    reason: string;
+    expected: unknown;
+    actual: unknown;
+};
+/**
+ * What running a case answered. A passing outcome carries `unobserved` where
+ * the adapter left `reports` undefined: the case passed on its output alone,
+ * and its report expectation was not checked.
+ */
+type Outcome = {
+    ok: true;
+    unobserved?: 'reports';
+} | Failure;
+/** A case ready to run: what identifies it, and the call that runs it. */
+type Planned = {
+    id: string;
+    file: string;
+    level: Level;
+    section: Section;
+    description: string;
+    execute: () => Outcome;
+};
+/** A case the plan left out, and why. */
+type Skipped = {
+    id: string;
+    file: string;
+    level: Level;
+    section: Section;
+    description: string;
+    reason: string;
+};
+type Plan = {
+    cases: Planned[];
+    skipped: Skipped[];
+};
+type Options = {
+    /** The fixtures to run; the shipped set when omitted. */
+    fixtures?: Fixture[];
+    /** Run only these levels, among those the adapter claims. */
+    levels?: readonly Level[];
+};
+type Result = {
+    passed: Planned[];
+    failed: (Planned & {
+        outcome: Failure;
+    })[];
+    skipped: Skipped[];
+    /** The cases among `passed` whose report expectation went unchecked, because the adapter observes no reports. */
+    unobserved: Planned[];
+};
+
+/** The catalogue of README.md, each behaviour a function of section 11's inputs. */
+declare const behaviours: Record<Behaviour, ModifierBehaviour>;
+
+/** The host value a fixture's JSON stands for: tagged objects replaced, everything else as JSON describes it. */
+declare const decode: (value: unknown) => unknown;
+
+/** The fixture files of a directory, sorted by name. */
+declare const load: (directory: string) => Fixture[];
+/** The set shipped with this package. */
+declare const fixtures: () => Fixture[];
+/** One entry per case the adapter's levels require, each ready to run, beside the cases left out and why. */
+declare const plan: (adapter: Adapter, options?: Options) => Plan;
+/** Executes a plan and sorts the outcomes. */
+declare const run: (adapter: Adapter, options?: Options) => Result;
+/** The text the command prints: one line per failure and per skipped case, then the counts. */
+declare const summarize: (result: Result) => string;
+/** Runs the set and throws where anything failed, listing every failure. */
+declare const check: (adapter: Adapter, options?: Options) => void;
+
+export { type Adapter, type Behaviour, type Case, type ConcreteCase, type Expected, type ExpectedReport, type Failure, type Fixture, type FixtureFile, type FormatRequest, type GeneratedCase, type Generator, type Level, type Limits, type Manifest, type ModifierBehaviour, type ModifierInput, type Options, type Outcome, type Plan, type Planned, type Report, type ReportCode, type ReportOrigin, type Resolution, type Resolved, type Result, type Section, type Skipped, behaviours, check, decode, fixtures, load, plan, run, summarize };

package/dist/index.js

@@ -0,0 +1,4 @@
+import{readdirSync as M,readFileSync as z}from"fs";import{join as D}from"path";import{fileURLToPath as U}from"url";var d={upper:({value:e})=>e.replace(/[a-z]/g,t=>t.toUpperCase()),echo:({value:e})=>e,empty:()=>"",nothing:()=>{},raise:()=>{throw new Error("The raise behaviour raised.")},default:({default:e})=>e(),options:({options:e})=>e.map(({key:t,value:r})=>`${t}=${r}`).join(","),props:({props:e})=>Object.keys(e).sort().map(t=>`${t}=${JSON.stringify(e[t])}`).join(","),locale:({locale:e})=>e??"none",object:({value:e})=>({answer:e})};var c="$curly",f=e=>{let t=[];for(let r=1;r<e;r=r*2+1)t=[t,t];return t},R=()=>{let e={};return e.self=e,e},j=e=>Object.hasOwn(e,c),F=e=>{switch(e[c]){case"undefined":return;case"unserializable":return R();case"nodes":if(typeof e.count!="number")throw new Error("A nodes tag needs a numeric count.");return f(e.count);default:throw new Error(`Unknown tag ${JSON.stringify(e[c])}.`)}},u=e=>Array.isArray(e)?e.map(u):e===null||typeof e!="object"?e:j(e)?F(e):Object.fromEntries(Object.entries(e).map(([t,r])=>[t,u(r)]));var p=(e,t,r)=>({ok:!1,reason:e,expected:t,actual:r}),h=e=>e!==null&&typeof e=="object",y=(e,t)=>{if(e===t)return!0;if(Array.isArray(e)&&Array.isArray(t))return e.length===t.length&&e.every((n,s)=>y(n,t[s]));if(!h(e)||!h(t)||Array.isArray(e)||Array.isArray(t))return!1;let r=Object.keys(e);return r.length===Object.keys(t).length&&r.every(n=>Object.hasOwn(t,n)&&y(e[n],t[n]))},S=({api:e,options:t,input:r},n)=>{switch(e){case"NumberFormat":return new Intl.NumberFormat(n,t).format(r);case"DateTimeFormat":return new Intl.DateTimeFormat(n,t).format(r);case"RelativeTimeFormat":{let[s,o]=r;return new Intl.RelativeTimeFormat(n,t).format(s,o)}}},C=e=>e&&Object.fromEntries(Object.entries(e).map(([t,r])=>[t,d[r]])),L=e=>{if(e.expected.format)return S(e.expected.format,e.locale);if(e.expected.output!==void 0)return e.expected.output;throw new Error(`The case ${e.id} expects neither an output nor a format.`)},P=e=>({input:{message:u(e.message),payload:u(e.payload),props:u(e.props),locale:e.locale,key:u(e.key),defaults:u(e.defaults),modifiers:C(e.modifiers)},expected:{output:L(e),reports:e.expected.reports??[]}}),l="limits",v=e=>Object.fromEntries(Array.from({length:e},(t,r)=>[`p${r+1}`,r+1<e?`{{p${r+2}}}`:"settled"])),m=(e,t)=>({code:e,origin:"limit",key:l,limit:t}),g={"passes-at-limit":({passes:e})=>({input:{message:"{{p1}}",payload:v(e),key:l},expected:{output:"settled",reports:[]}}),"passes-over-limit":({passes:e})=>({input:{message:"{{p1}}",payload:v(e+1),key:l},expected:{output:`{{p${e+1}}}`,reports:[m("pass-limit",e)]}}),"output-at-limit":({output:e})=>({input:{message:"{{v}}",payload:{v:"x".repeat(e)},key:l},expected:{output:"x".repeat(e),reports:[]}}),"output-over-limit":({output:e})=>({input:{message:"{{v}}",payload:{v:"x".repeat(e+1)},key:l},expected:{output:"{{v}}",reports:[m("output-limit",e)]}}),"output-over-limit-stops":({output:e})=>{let t=!1,r=n=>(t=!0,d.raise(n));return{input:{message:"{{v}}{{w:raise}}",payload:{v:"x".repeat(e+1),w:"w"},key:l,modifiers:{raise:r}},expected:{output:"{{v}}{{w:raise}}",reports:[m("output-limit",e)]},verify:()=>t?p("The modifier past the output limit was called.","not called","called"):void 0}},"conversion-over-limit":({conversion:e})=>({input:{message:"{{v; default:D}}",payload:{v:f(e+1)},key:l},expected:{output:"D",reports:[{code:"unserializable-value",origin:"payload",key:l}]}})},N=["origin","key","limit"],w=e=>`${e.length} ${e.length===1?"report":"reports"}`,I=(e,t)=>{if(e.length!==t.length)return p(`Expected ${w(e)}, got ${w(t)}.`,e,t);for(let[r,n]of t.entries()){let s=e[r],o=`report ${r+1}`;if(n.code!==s.code)return p(`The code of ${o} differs.`,s,n);let i=N.find(a=>n[a]!==void 0&&s[a]!==void 0&&!y(n[a],s[a]));if(i)return p(`The ${i} of ${o} differs.`,s,n)}},G=e=>{if(e instanceof Error)return e.message;try{return JSON.stringify(e)??String(e)}catch{return String(e)}},J=(e,t,r)=>{let n;try{n=e.resolve(t)}catch(s){return p("The adapter raised.",r,G(s))}return h(n)?typeof n.then=="function"?p("The adapter answered asynchronously; resolve must answer at once.",r,"a promise"):n:p("The adapter answered with no resolution.",r,n)},x=(e,{input:t,expected:r,verify:n})=>{let s=J(e,t,r.output);if("ok"in s)return s;if(s.output!==r.output)return p("The output differs.",r.output,s.output);let o=n?.();return o||(s.reports===void 0?{ok:!0,unobserved:"reports"}:Array.isArray(s.reports)?I(r.reports,s.reports)??{ok:!0}:p("The reports are not a list.",r.reports,s.reports))},k=(e,t)=>x(e,P(t)),$=(e,t)=>{if(!Object.hasOwn(g,t.generate))throw new Error(`The case ${t.id} names no construction: ${JSON.stringify(t.generate)}.`);return x(e,g[t.generate](e.limits))};var B=e=>M(e).filter(t=>t.endsWith(".json")).sort().map(t=>({name:t,file:JSON.parse(z(D(e,t),"utf8"))})),q=()=>B(U(new URL("../fixtures/",import.meta.url))),K="output-over-limit-stops",W=["core","intl","extensions"],H=["passes","output","conversion"],V=(e,t)=>{let r=(o,i)=>{let a=o.find(E=>!W.includes(E));if(a!==void 0)throw new Error(`${i} names the level ${JSON.stringify(a)}; the levels are core, intl and extensions.`)};if(!Array.isArray(e.levels))throw new Error("The adapter must list the levels it claims.");if(r(e.levels,"The adapter"),!e.levels.includes("core"))throw new Error("The adapter must claim the core level.");if(t.levels){r(t.levels,"The levels option");let o=t.levels.find(i=>!e.levels.includes(i));if(o!==void 0)throw new Error(`The adapter does not claim the ${o} level.`)}let n=e.limits,s=H.find(o=>!Number.isInteger(n?.[o])||n?.[o]<1);if(s)throw new Error(`The adapter must declare its ${s} limit as a positive integer.`)},b=(e,t,r)=>{if(!t.levels.includes(e))return`The adapter does not claim the ${e} level.`;if(r.levels&&!r.levels.includes(e))return`The ${e} level is not among the levels being run.`},Y=(e,t,r,n)=>{let s=b(t,r,n);if(s)return s;if("generate"in e&&e.generate===K&&b("extensions",r,n))return"The case registers a host-defined modifier, which needs the extensions level."},_=(e,t={})=>{V(e,t);let r=(t.fixtures??q()).flatMap(({name:o,file:i})=>i.cases.map(a=>({c:a,identity:{id:a.id,file:o,level:i.level,section:a.section??i.section,description:a.description},skip:Y(a,i.level,e,t)}))),n=r.filter(({skip:o})=>!o).map(({c:o,identity:i})=>({...i,execute:()=>"generate"in o?$(e,o):k(e,o)})),s=r.flatMap(({identity:o,skip:i})=>i?[{...o,reason:i}]:[]);return{cases:n,skipped:s}},Q=(e,t={})=>{let{cases:r,skipped:n}=_(e,t),s=r.map(o=>[o,o.execute()]);return{passed:s.filter(([,o])=>o.ok).map(([o])=>o),failed:s.flatMap(([o,i])=>i.ok?[]:[{...o,outcome:i}]),skipped:n,unobserved:s.filter(([,o])=>o.ok&&o.unobserved).map(([o])=>o)}},T=200,O=e=>{let t;try{t=JSON.stringify(e)??String(e)}catch{t=String(e)}return t.length>T?`${t.slice(0,T)}...`:t},A=({id:e,section:t,description:r,outcome:n})=>`FAIL ${e} (section ${t}): ${n.reason} Expected ${O(n.expected)}, actual ${O(n.actual)}. ${r}`,X=({id:e,section:t,reason:r})=>`SKIP ${e} (section ${t}): ${r}`,ue=e=>{let t=`${e.passed.length} passed, ${e.failed.length} failed, ${e.skipped.length} skipped`,r=e.unobserved.length?`, ${e.unobserved.length} passed with reports unobserved`:"";return[...e.failed.map(A),...e.skipped.map(X),`${t}${r}`].join(`
+`)},pe=(e,t={})=>{let r=Q(e,t);if(r.failed.length)throw new Error(`${r.failed.length} of ${r.passed.length+r.failed.length} conformance cases failed:
+${r.failed.map(A).join(`
+`)}`)};export{d as behaviours,pe as check,u as decode,q as fixtures,B as load,_ as plan,Q as run,ue as summarize};