docs: new design for the documentation site (#5934)

* docs: new design for the documentation site Apply the brand to the Material for MkDocs site: Inter and JetBrains Mono served by the site (upright and real italic), brand colours, blue header band with the syntax pattern, wordmark in the header, new home page (hero, cards, animated feature tour), 404 page, polish for tabs, search, footer, focus rings, tables and code blocks, and theme features (code copy, previous/next footer, TOC follow, search suggestions). Draw the number railroad diagram, the parser callback events and the iterator illustrations as inline SVGs that follow the light and dark scheme. The generator scripts are in docs/mkdocs/scripts/figures; the feature slideshow (json-light.svg, json-dark.svg, replacing json.gif on the home page) is built by docs/mkdocs/scripts/slideshow. Decision nodes in five flowcharts become hexagons, which need far less room. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: add figures, table captions and a macro chooser - Figures with numbered captions: SAX stepper, json_view layout and edit stepper, exception map, JSON pointer and patch walkers, QA pipeline, scaling and binary size charts, roadmap lanes, release timeline, integration decision tree and namespace builder - Table captions (nj-table-caption) on 9 pages - Compile times: modules and PCH charts, filesystem section, re-measured Figure 1, links between features/modules.md and compile_times.md - Interactive macro chooser for features/arbitrary_types.md - Link check: exclude URLs that answer the plugin with 400/401/419 or are dead (customers.md) Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: macro chooser generates adl_serializer for non-default-constructible types Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: cross-link concept pages and API pages in See also sections Add See also links in both directions between the concept pages (features, home, integration) and the API pages, write API links in code font, give every entry a comment after a dash, and show the callback event figure on the parser callbacks page. Signed-off-by: Niels Lohmann <mail@nlohmann.me> * docs: address review comments on the new design - Home: add a "Latest release" button - Sponsors: update the list and group it by tier - Features: list all feature pages on the index page - Releases: add highlights per release, link the 4.0 roadmap, add the first commit to the timeline - Exceptions: prefix all example messages with the exception name - API: no code font for format names in the See also links of the to_/from_ pages - Merge Patch: show the document before, the patch, and the result - Replace "--" with typographic dashes, mark external links with an icon, center Mermaid diagrams Signed-off-by: Niels Lohmann <mail@nlohmann.me> --------- Signed-off-by: Niels Lohmann <mail@nlohmann.me>
2026-11-01 13:10:38 +00:00 · 2026-10-27 07:41:42 +01:00
1 parent 2bb2feeef4
commit a47170346a
@@ -13,6 +13,8 @@ flowchart LR
    A --> V["bool: is the input valid JSON?"]
 ```

+<p class="nj-caption" markdown>The three entry points for parsing: `parse()` builds a `basic_json` value, optionally filtered by a parser callback, `sax_parse()` delivers events to a SAX handler, and `accept()` only checks whether the input is valid.</p>
+
 ## Input

 The [`parse`](../../api/basic_json/parse.md) function reads a JSON value from an input. The input can be
@@ -34,7 +36,7 @@ json data = json::parse(f);
 ```

 The input must be encoded in UTF-8; other encodings are not supported. The exception is wide-character input, which
-is read as UTF-16 or UTF-32 -- depending on the character type -- and converted to UTF-8; see the
+is read as UTF-16 or UTF-32 — depending on the character type — and converted to UTF-8; see the
 [`parse`](../../api/basic_json/parse.md) page for an example. A single input may contain only one JSON value.
 Inputs consisting of multiple values separated by newlines are handled by the [JSON Lines](json_lines.md) format; input
 that arrives in chunks or contains several values is covered in
@@ -154,4 +156,11 @@ options.
 - [Zero-copy JSON views](../json_view.md) - parse into a read-only document and read it through views
 - [parsing and exceptions](parse_exceptions.md) - control error handling
 - [parsing untrusted input](untrusted_input.md) - what to consider when parsing input from untrusted sources
- [Zero-copy JSON views](../json_view.md) - parse into a document and read it through a view
+- [`operator>>`](../../api/operator_gtgt.md) - deserialize from stream
+- [`json_sax`](../../api/json_sax/index.md) - documentation of the SAX interface
+- [`parse_error`](../../api/basic_json/parse_error.md) - exception thrown on a parse error
+- [Comments](../comments.md) - ignore `//` and `/* */` comments while parsing
+- [Trailing Commas](../trailing_commas.md) - accept trailing commas in arrays and objects
+- [Serialization](../serialization.md) - pretty-printing, UTF-8 handling, and number output
+- [Working Without Exceptions](../no_exceptions.md) - error handling when exceptions are disabled
+- [Exceptions](../../home/exceptions.md) - list of exceptions and error codes
@@ -61,5 +61,12 @@ JSON Lines input with more than one value is treated as invalid JSON by the [`pa
    }
    ```

-    A value that is a number must be followed by whitespace -- see the [notes](../../api/operator_gtgt.md#notes) of
+    A value that is a number must be followed by whitespace — see the [notes](../../api/operator_gtgt.md#notes) of
    `operator>>` for details.
+
+## See also
+
+- [Parsing](index.md) - overview of the parsing functions
+- [Large, Streamed, and Partial Input](large_and_partial_input.md) - chunked, concatenated, and very large input
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [`operator>>`](../../api/operator_gtgt.md) - deserialize from stream
@@ -17,6 +17,8 @@ flowchart TD
    H -->|"yes"| I["stop early with SAX, or read through a view"]
 ```

+<p class="nj-caption" markdown>Questions about the input and the approach this page describes for each; an input can match more than one question.</p>
+
 ## Several values in one stream

 For newline-delimited input, read line by line and parse each line, as described in [JSON Lines](json_lines.md). For
@@ -80,6 +82,14 @@ exception is one past the buffer size in the first case:
 The example feeds a document in five chunks. The first four are reported as incomplete, and a syntax error is reported as
 such, not as missing data.

+The chunks of the example, and the bytes each attempt parses again:
+
+<div class="nj-fig-wrap" markdown>
+--8<-- "images/chunk_buffering.svg"
+</div>
+
+<p class="nj-caption" markdown>Each row is one parse attempt on the growing buffer: an error at the byte after the end of the buffer means the value is incomplete, an error before the end is a real syntax error. The last line adds up the bytes parsed over all attempts.</p>
+
 !!! warning "Limits of buffering"

    - The buffer must contain exactly one value. Data that belongs to the next value is a syntax error. Use framing if
@@ -93,6 +103,14 @@ such, not as missing data.

 The input does not have to become one huge `json` value. The two tools below process it piece by piece.

+How the memory use develops while a large array of records is parsed (illustrative, not a measurement):
+
+<div class="nj-fig-wrap" markdown>
+--8<-- "images/memory_over_time.svg"
+</div>
+
+<p class="nj-caption" markdown>Memory use over the number of records parsed: `parse()` keeps the whole tree, `json_document` the text plus its index, a discarding callback one record at a time, and SAX only what the handler keeps.</p>
+
 ### Handle and discard elements with a callback

 A [parser callback](parser_callbacks.md) is called for every finished value. If it returns `#!cpp false`, the value is
@@ -152,3 +170,8 @@ and gives read-only [views](../../api/basic_json_view/index.md) of the parts you
 - [SAX interface](sax_interface.md) - event-based parsing
 - [Zero-copy JSON views](../json_view.md) - read parts of a large document without building a tree
 - [Untrusted input](untrusted_input.md) - limits for input you do not control
+- [`operator>>`](../../api/operator_gtgt.md) - deserialize from stream
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
+- [`JSON_PRECISE_STREAM_POSITION`](../../api/macros/json_precise_stream_position.md) - leave the stream positioned right after a parsed number
+- [`JSON_DISABLE_STREAM_BULK_SCAN`](../../api/macros/json_disable_stream_bulk_scan.md) - read a `std::istream` one character at a time
@@ -143,3 +143,14 @@ acceptable, for example for configuration files. Note that `start_pos()` is a 0-
 For binary formats such as CBOR, there are no lines; `byte` is the position in the byte sequence. To find out how many
 bytes a successfully parsed value used, see
 [Several values in one stream](large_and_partial_input.md#several-values-in-one-stream).
+
+## See also
+
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [`accept`](../../api/basic_json/accept.md) - check if the input is valid JSON
+- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
+- [`parse_error`](../../api/basic_json/parse_error.md) - exception thrown on a parse error
+- [`JSON_DIAGNOSTIC_POSITIONS`](../../api/macros/json_diagnostic_positions.md) - record start and end positions of parsed values
+- [Working Without Exceptions](../no_exceptions.md) - error handling when exceptions are disabled
+- [Exceptions](../../home/exceptions.md) - list of exceptions and error codes
+- [Parsing Untrusted Input](untrusted_input.md) - limits and checks for input you do not control
@@ -31,6 +31,13 @@ table describes the values of the parameters `depth`, `event`, and `parsed`.
 | `parse_event_t::array_end`    | the parser read `]` and finished processing a JSON array  | depth of the parent of the JSON array     | the parsed JSON array            |
 | `parse_event_t::value`        | the parser finished reading a JSON value                  | depth of the value                        | the parsed JSON value            |

+<div class="nj-fig-wrap" markdown>
+--8<-- "images/callback_events.svg"
+</div>
+
+<p class="nj-caption" markdown>Each coloured dot marks where the parser reports a `parse_event_t` event while reading
+the JSON text on the left; the legend on the right names the event per colour.</p>
+
 ??? example "Example: sequence of callback events"

    When parsing the following JSON text,
@@ -95,7 +102,7 @@ was called:

 The JSON specification leaves the handling of objects with repeated keys up to the implementation. As described in
 [`object_t`](../../api/basic_json/object_t.md#behavior), it is unspecified which value for a repeated key ends up in
-the resulting `#!c json` value -- once parsing has produced that value, the duplicate is already gone, because object
+the resulting `#!c json` value — once parsing has produced that value, the duplicate is already gone, because object
 storage maps each key to a single value. If duplicate keys should instead be treated as an error, a parser callback
 can detect them while the object is still being read, before that ambiguity ever applies.

@@ -122,7 +129,7 @@ This approach has three limitations:
  maintaining a stack of the enclosing keys and array indices in the callback as well.

 A [SAX interface](sax_interface.md) does not lift the position limitation: its `key` function receives no position
-either -- only `parse_error` is passed the byte position.
+either — only `parse_error` is passed the byte position.

 ## Recipe: streaming a large homogeneous array

@@ -171,3 +178,11 @@ tracking the maximum `depth` seen and throwing once it is exceeded:

    json::parse(input, callback);
    ```
+
+## See also
+
+- [Parsing](index.md) - overview of the parsing functions
+- [SAX Interface](sax_interface.md) - guide to event-based parsing
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [`parser_callback_t`](../../api/basic_json/parser_callback_t.md) - callback function type for the parser
+- [`parse_event_t`](../../api/basic_json/parse_event_t.md) - enumeration of parser events
@@ -29,6 +29,8 @@ class sax_t ["json::sax_t"] {
 }
 ```

+<p class="nj-caption" markdown>The interface `json::sax_t`: one function per event, each returning `bool`; the functions marked with `*` are pure virtual.</p>
+
 ```cpp
 // called when null is parsed
 bool null();
@@ -62,6 +64,34 @@ bool parse_error(std::size_t position, const std::string& last_token, const json

 The return value of each function determines whether parsing should proceed.

+## Stepping through the events
+
+The events for a small input, step by step, and what two different handlers do with them. Press *Play* or step with *Next*:
+
+<div class="nj-sax nj-fig" id="sax-event-stepper" data-nj-sax role="group" aria-label="SAX events for the input {&quot;a&quot;:[1,true],&quot;b&quot;:&quot;x&quot;}, and the state of a handler after each event">
+<div class="nj-sax__lane nj-sax__lane--text"><p class="nj-sax__h">input</p><p class="nj-sax__text"><code class="nj-sax__src">{"a":[1,true],"b":"x"}</code></p></div>
+<div class="nj-sax__lane nj-sax__lane--events"><p class="nj-sax__h">events, in the order the parser calls them</p><ol class="nj-sax__events">
+<li class="nj-sax-ev nj-sax-ev--os"><code>start_object(-1)</code></li>
+<li class="nj-sax-ev nj-sax-ev--k"><code>key("a")</code></li>
+<li class="nj-sax-ev nj-sax-ev--as"><code>start_array(-1)</code></li>
+<li class="nj-sax-ev nj-sax-ev--v"><code>number_unsigned(1)</code></li>
+<li class="nj-sax-ev nj-sax-ev--v"><code>boolean(true)</code></li>
+<li class="nj-sax-ev nj-sax-ev--ae"><code>end_array()</code></li>
+<li class="nj-sax-ev nj-sax-ev--k"><code>key("b")</code></li>
+<li class="nj-sax-ev nj-sax-ev--v"><code>string("x")</code></li>
+<li class="nj-sax-ev nj-sax-ev--oe"><code>end_object()</code></li>
+</ol></div>
+<div class="nj-sax__lane nj-sax__lane--state"><p class="nj-sax__h">handler: build a value tree, as <code>parse</code> does</p><div class="nj-sax__state"><pre class="nj-sax__tree"><code>{
+  "a": [
+    1,
+    true
+  ],
+  "b": "x"
+}</code></pre><p class="nj-sax__note">After <code>end_object()</code> the tree is complete and no container is open. The number of elements is passed as -1: the parser does not know it in advance.</p></div></div>
+</div>
+
+<p class="nj-caption" markdown>The three lanes show the input consumed so far, the events called so far, and the state of the selected handler (*build a tree* or *keep only /b*). Check *return false at this event* to stop the parse at the current event and see which events are no longer called.</p>
+
 To implement your own SAX handler, proceed as follows:

 1. Implement the SAX interface in a class. You can use class `nlohmann::json_sax<json>` as base class, but you can also use any class where the functions described above are implemented and public.
@@ -72,5 +102,9 @@ Note the `sax_parse` function only returns a `#!cpp bool` indicating the result

 ## See also

- [json_sax](../../api/json_sax/index.md) - documentation of the SAX interface
- [sax_parse](../../api/basic_json/sax_parse.md) - SAX parser
+- [`json_sax`](../../api/json_sax/index.md) - documentation of the SAX interface
+- [`sax_parse`](../../api/basic_json/sax_parse.md) - SAX parser
+- [Parsing](index.md) - overview of the parsing functions
+- [Parsing and Exceptions](parse_exceptions.md) - handling parse errors and locating them in the input
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [Binary Formats](../binary_formats/index.md) - CBOR, MessagePack, BSON, and other formats
@@ -1,7 +1,7 @@
 # Parsing Untrusted Input

-This page is for applications that parse JSON -- or one of the supported [binary formats](../binary_formats/index.md)
-(BJData, BON8, BSON, CBOR, MessagePack, UBJSON) -- from a source they do not fully control, such as a network
+This page is for applications that parse JSON — or one of the supported [binary formats](../binary_formats/index.md)
+(BJData, BON8, BSON, CBOR, MessagePack, UBJSON) — from a source they do not fully control, such as a network
 connection, an uploaded file, or another process. It summarizes what the library already does for such input and what
 remains the caller's responsibility, linking to the pages that cover each aspect in detail rather than repeating them.

@@ -50,12 +50,12 @@ stack, however deeply it is nested.
    [SAX handler](sax_interface.md) (for the JSON parser or a binary format alike) and throwing once your limit is
    exceeded.

-Once a value has been parsed, operations that walk it recursively -- serializing it with
+Once a value has been parsed, operations that walk it recursively — serializing it with
 [`dump`](../../api/basic_json/dump.md), hashing it, copying it, comparing two values with `#!cpp ==`, `#!cpp <`, or (in
 C++20) `#!cpp <=>`, merging with [`update`](../../api/basic_json/update.md), applying a
 [`merge_patch`](../../api/basic_json/merge_patch.md), creating a patch with [`diff`](../../api/basic_json/diff.md) or
 [`merge_diff`](../../api/basic_json/merge_diff.md), [`flatten`](../../api/basic_json/flatten.md), and the binary
-writers (`to_cbor`, `to_msgpack`, ...) -- descend at most 128 levels on the call stack and continue
+writers (`to_cbor`, `to_msgpack`, ...) — descend at most 128 levels on the call stack and continue
 below that with an explicit stack instead, so none of them can exhaust the stack either, however deeply the value is
 nested. Destroying a value (its destructor) never recurses at all, regardless of nesting depth, for the same reason.

@@ -63,12 +63,12 @@ nested. Destroying a value (its destructor) never recurses at all, regardless of

 The library does not limit the overall size of a JSON text; a value nested or wide enough will use memory
 proportional to the input. If you parse untrusted input of unbounded size, check the size of the file or stream
-yourself before -- or while -- handing it to `parse()`.
+yourself before — or while — handing it to `parse()`.

 For the binary formats, an announced size is never trusted outright:

 - Reading a string or binary value copies the input in bounded 4096-byte chunks and grows the result as bytes are
-  actually consumed, rather than allocating the announced length up front -- a truncated input runs out of bytes
+  actually consumed, rather than allocating the announced length up front — a truncated input runs out of bytes
  (reported as a parse error) instead of triggering an oversized allocation.
 - When an array announces its number of elements and the array container supports `reserve()` (as `#!cpp std::vector`,
  the default, does), the library reserves storage for at most 16384 of them upfront, regardless of how large the
@@ -91,7 +91,7 @@ Invalid UTF-8 is rejected while parsing, not just while serializing:

 A `#!cpp '\0'` (NUL) byte *inside* a quoted JSON string is always rejected (it must be escaped as `\u0000`). A NUL byte
 *outside* of a string is different: by default it is silently treated as the end of the input, so trailing bytes after
-it -- including further, otherwise well-formed JSON -- are silently ignored rather than rejected. Since untrusted input
+it — including further, otherwise well-formed JSON — are silently ignored rather than rejected. Since untrusted input
 that happens to embed a NUL is a way to make part of it disappear without a parse error, see the
 [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) and consider defining
 [`JSON_STRICT_NUL_HANDLING`](../../api/macros/json_strict_nul_handling.md) to `1` to reject a NUL byte like any other
@@ -116,7 +116,7 @@ silently resolving them one way or another, see the

 ## Numbers

-A number whose value cannot be represented -- for instance `1E1000`, which overflows `double` -- is rejected while
+A number whose value cannot be represented — for instance `1E1000`, which overflows `double` — is rejected while
 parsing as [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406) rather than silently becoming
 infinity. An integer that is syntactically valid but does not fit the 64-bit integer types is not rejected; it is
 instead stored as a `double`, which may lose precision for very large values. See
@@ -139,7 +139,7 @@ conforming JSON consumers is exactly what the default rejects.
  [SAX handler](sax_interface.md); the library bounds the call stack but not memory use.
 - Bound the size of the input itself before parsing, independent of the library's own bounded allocations for binary
  format lengths.
- Decide up front how you want a string with invalid UTF-8 -- from any source, not only parsing -- to be serialized
+- Decide up front how you want a string with invalid UTF-8 — from any source, not only parsing — to be serialized
  (`strict`, `replace`, or `ignore`), rather than discovering it from an uncaught `type_error.316`.
 - If a stray NUL byte silently truncating trailing input is a problem for your input format, define
  `JSON_STRICT_NUL_HANDLING`.
@@ -160,3 +160,9 @@ report a security issue in the library itself, follow the [security policy](../.
 - [Number handling](../types/number_handling.md) - number ranges and overflow behavior
 - [Assurance case](../../community/assurance_case.md) - the library's threat model and countermeasures
 - [Security policy](../../community/security_policy.md) - how to report a vulnerability
+- [`parse`](../../api/basic_json/parse.md) - deserialize from a compatible input
+- [`accept`](../../api/basic_json/accept.md) - check if the input is valid JSON
+- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
+- [`parser_callback_t`](../../api/basic_json/parser_callback_t.md) - callback function type for the parser
+- [`JSON_STRICT_NUL_HANDLING`](../../api/macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
+- [`JSON_DIAGNOSTIC_POSITIONS`](../../api/macros/json_diagnostic_positions.md) - record start and end positions of parsed values