@xmachines/docs 4.0.0 → 5.0.1

package/api/@xmachines/play-pattern/functions/buildPath.md

@@ -0,0 +1,46 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / buildPath
+
+# Function: buildPath()
+
+```ts
+function buildPath(pattern, params?, options?): PathBuildResult;
+```
+
+Defined in: [pattern-grammar.ts:713](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L713)
+
+Builds the path that a pattern describes, with each param filled from `params`.
+
+This is the OUTBOUND half of the language, and it reads the same parse as the match.
+The walk drops an optional part that has no value TOGETHER with the `/` that the part
+absorbed, which is the prefix rule of the module comment: `/settings/:section?` builds
+`/settings`, and not `/settings/`.
+
+The function reports a fault through its return value, and it throws never. The
+`reason` field names the fault: `missing` for a param that needs a value and has none,
+and `unresolvable` for a param that carries a value no path can hold. A caller raises
+the error of its own layer — `@xmachines/play-xstate` raises `MissingRouteParamError`
+for the first one and `InvalidRouteParamError` for the second.
+
+## Parameters
+
+| Parameter  | Type                                            | Description                                                           |
+| ---------- | ----------------------------------------------- | --------------------------------------------------------------------- |
+| `pattern`  | `string`                                        | The route pattern, for example `/profile/:userId`.                    |
+| `params`   | [`PathParams`](../type-aliases/PathParams.md)   | The value of each param, keyed by the name that the pattern declares. |
+| `options?` | [`ParseOptions`](../interfaces/ParseOptions.md) | -                                                                     |
+
+## Returns
+
+[`PathBuildResult`](../type-aliases/PathBuildResult.md)
+
+The path, or the reason that stopped the walk with the param that carries it.
+
+## Example
+
+```typescript
+buildPath("/profile/:userId", { userId: "alice" }); // { ok: true, path: "/profile/alice" }
+buildPath("/settings/:section?", {}); // { ok: true, path: "/settings" }
+buildPath("/tags/c\\+\\+", {}); // { ok: true, path: "/tags/c++" }
+buildPath("/profile/:userId", {}); // { ok: false, reason: "missing", missing: "userId" }
+buildPath("/files/:name", { name: ".." }); // { ok: false, reason: "unresolvable", … }
+```

package/api/@xmachines/play-pattern/functions/createPatternCache.md

@@ -0,0 +1,47 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / createPatternCache
+
+# Function: createPatternCache()
+
+```ts
+function createPatternCache<V>(maxSize?): PatternCache<V>;
+```
+
+Defined in: [cache.ts:85](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L85)
+
+Builds a cache that forgets its least recently used entries.
+
+## The algorithm
+
+Two maps, and no list. `recent` takes every write. When a write fills `recent`, it
+becomes `old` and a new `recent` opens, which drops the previous `old` whole. A read of
+a key of `old` moves the entry into `recent`, and THAT is what makes the eviction an
+LRU one rather than a FIFO one: an entry that every lookup reads moves forward, and an
+entry that nothing reads falls out with the map that holds it.
+
+The cache therefore holds between `maxSize` and `2 * maxSize` entries, and it does no
+bookkeeping for a read that hits `recent`.
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `V`            |
+
+## Parameters
+
+| Parameter | Type     | Default value | Description                                                                                                                                                                                                          |
+| --------- | -------- | ------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `maxSize` | `number` | `500`         | The number of entries that `recent` holds. It is `1` at the least, and the default is `500`. A value that is not a finite number reads as the default, so a cache with no eviction at all cannot happen by accident. |
+
+## Returns
+
+[`PatternCache`](../interfaces/PatternCache.md)\<`V`\>
+
+A cache. It is not shared: each call builds one.
+
+## Example
+
+```typescript
+const cache = createPatternCache<ParsedPattern>(50);
+parsePattern("/profile/:userId", { patternCache: cache });
+```

package/api/@xmachines/play-pattern/functions/getIndexKey.md

@@ -0,0 +1,30 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / getIndexKey
+
+# Function: getIndexKey()
+
+```ts
+function getIndexKey(path): string;
+```
+
+Defined in: [pattern-grammar.ts:201](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L201)
+
+Computes the key of the bucket index of a concrete PATH.
+
+The key is the first path segment, for example `"settings"` of `"/settings/billing"`.
+The root path `"/"` gives the key `"/"`, and a path whose first segment is EMPTY —
+`"//docs"` — gives the key `""`. The two are different keys, so a pattern that matches
+both asks [ParsedPattern.indexKey](../interfaces/ParsedPattern.md#property-indexkey) for the wildcard key instead.
+
+[ParsedPattern.indexKey](../interfaces/ParsedPattern.md#property-indexkey) computes the key of a PATTERN, and it calls this
+function for every pattern whose first segment is a literal. One function therefore
+answers both sides, and a pattern in the wrong bucket cannot happen.
+
+## Parameters
+
+| Parameter | Type     | Description               |
+| --------- | -------- | ------------------------- |
+| `path`    | `string` | The string of a URL path. |
+
+## Returns
+
+`string`

package/api/@xmachines/play-pattern/functions/isDotSegment.md

@@ -0,0 +1,40 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / isDotSegment
+
+# Function: isDotSegment()
+
+```ts
+function isDotSegment(segment): boolean;
+```
+
+Defined in: [pattern-grammar.ts:872](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L872)
+
+Answers whether one segment resolves away in a URL, rather than naming itself.
+
+A URL parser reads the dot segments BEFORE it decodes the percent escapes, and it counts
+`%2e` as the dot. The WHATWG URL standard names six forms, and a browser resolves every
+one of them out of a location: `.` and `%2e` for the single dot, and `..`, `.%2e`, `%2e.`
+and `%2e%2e` for the double dot. Each percent test is case-insensitive.
+
+NO encoding of `.` or `..` therefore survives. A param that carries one describes a path
+that its own pattern matches back never, so [buildPath](buildPath.md) refuses it, and
+`normalizeBasePath` of `@xmachines/play-url` refuses the same value in a base path.
+
+Give the segment in the form that the URL carries, and encode nothing here. The two
+callers reach that form by two roads, and both are correct. [buildPath](buildPath.md) encodes a
+param value first, so a value that HOLDS a percent sign arrives with that sign escaped:
+the string `"%2e"` encodes to `"%252e"`, which names itself and stays. `normalizeBasePath`
+of `@xmachines/play-url` reads a path that an author wrote, which is encoded already, so
+it passes the segment RAW and `"%2e"` there is the dot. A caller that encodes an
+already-encoded segment a second time hides every `%2e` from this test.
+
+## Parameters
+
+| Parameter | Type     | Description                                                                         |
+| --------- | -------- | ----------------------------------------------------------------------------------- |
+| `segment` | `string` | ONE path segment, with no separator around it, in the form that the URL carries it. |
+
+## Returns
+
+`boolean`
+
+`true` when a URL resolves the segment away.

package/api/@xmachines/play-pattern/functions/parsePattern.md

@@ -0,0 +1,28 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / parsePattern
+
+# Function: parsePattern()
+
+```ts
+function parsePattern(pattern, options?): ParsedPattern;
+```
+
+Defined in: [pattern-grammar.ts:264](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L264)
+
+Reads a route pattern, one time for each distinct pattern.
+
+The parser reports a fault never. A pattern that it cannot read reports
+`parameterized: true` and `bareForm: null`, which sends it to the URLPattern
+constructor and keeps every derived answer on the safe side.
+
+## Parameters
+
+| Parameter  | Type                                            | Description                                        |
+| ---------- | ----------------------------------------------- | -------------------------------------------------- |
+| `pattern`  | `string`                                        | The route pattern, for example `/profile/:userId`. |
+| `options?` | [`ParseOptions`](../interfaces/ParseOptions.md) | -                                                  |
+
+## Returns
+
+[`ParsedPattern`](../interfaces/ParsedPattern.md)
+
+The parse. The caller treats it as read-only: the cache holds this object.

package/api/@xmachines/play-pattern/interfaces/GroupPart.md

@@ -0,0 +1,15 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / GroupPart
+
+# Interface: GroupPart
+
+Defined in: [pattern-grammar.ts:92](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L92)
+
+A `{…}` group, which carries its own parts and its own modifier.
+
+## Properties
+
+| Property                                  | Modifier   | Type                                                       | Defined in                                                                                                                         |
+| ----------------------------------------- | ---------- | ---------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-kind"></a> `kind`         | `readonly` | `"group"`                                                  | [pattern-grammar.ts:93](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L93) |
+| <a id="property-modifier"></a> `modifier` | `readonly` | [`PatternModifier`](../type-aliases/PatternModifier.md)    | [pattern-grammar.ts:95](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L95) |
+| <a id="property-parts"></a> `parts`       | `readonly` | readonly [`PatternPart`](../type-aliases/PatternPart.md)[] | [pattern-grammar.ts:94](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L94) |

package/api/@xmachines/play-pattern/interfaces/LiteralPart.md

@@ -0,0 +1,14 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / LiteralPart
+
+# Interface: LiteralPart
+
+Defined in: [pattern-grammar.ts:59](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L59)
+
+A run of literal characters, with every escape already resolved.
+
+## Properties
+
+| Property                          | Modifier   | Type        | Description                                                     | Defined in                                                                                                                         |
+| --------------------------------- | ---------- | ----------- | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-kind"></a> `kind` | `readonly` | `"literal"` | -                                                               | [pattern-grammar.ts:60](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L60) |
+| <a id="property-text"></a> `text` | `readonly` | `string`    | The characters that a path must carry, for example `/settings`. | [pattern-grammar.ts:62](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L62) |

package/api/@xmachines/play-pattern/interfaces/ParamPart.md

@@ -0,0 +1,21 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / ParamPart
+
+# Interface: ParamPart
+
+Defined in: [pattern-grammar.ts:71](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L71)
+
+A param: `:name`, `(\d+)`, or `*`.
+
+An anonymous param carries no `name`. URLPattern numbers such a group from `0`, and
+this library reports it to no machine — see [ParsedPattern.params](ParsedPattern.md#property-params).
+
+## Properties
+
+| Property                                    | Modifier   | Type                                                    | Description                                                                                                                                                                                                                                                                                                                                                 | Defined in                                                                                                                         |
+| ------------------------------------------- | ---------- | ------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
+| <a id="property-groupname"></a> `groupName` | `readonly` | `string` \| `null`                                      | The name that URLPattern compiles, with each hyphen rewritten to an underscore, or `null` for an anonymous param. The rewrite happens ONE time, here, and [ParsedPattern.normalized](ParsedPattern.md#property-normalized) carries the same characters. A caller that needs the group name of a param reads this field, and it rewrites nothing of its own. | [pattern-grammar.ts:83](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L83) |
+| <a id="property-kind"></a> `kind`           | `readonly` | `"param"`                                               | -                                                                                                                                                                                                                                                                                                                                                           | [pattern-grammar.ts:72](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L72) |
+| <a id="property-modifier"></a> `modifier`   | `readonly` | [`PatternModifier`](../type-aliases/PatternModifier.md) | -                                                                                                                                                                                                                                                                                                                                                           | [pattern-grammar.ts:88](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L88) |
+| <a id="property-name"></a> `name`           | `readonly` | `string` \| `null`                                      | The declared name, with each hyphen kept, or `null` for an anonymous param.                                                                                                                                                                                                                                                                                 | [pattern-grammar.ts:74](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L74) |
+| <a id="property-prefix"></a> `prefix`       | `readonly` | `string`                                                | The `/` that the param absorbed from the literal before it, or `""`.                                                                                                                                                                                                                                                                                        | [pattern-grammar.ts:87](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L87) |
+| <a id="property-regexp"></a> `regexp`       | `readonly` | `string` \| `null`                                      | The source of the constraint of `:id(\d+)`, or `null` when the param declares none.                                                                                                                                                                                                                                                                         | [pattern-grammar.ts:85](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L85) |

package/api/@xmachines/play-pattern/interfaces/ParseOptions.md

@@ -0,0 +1,19 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / ParseOptions
+
+# Interface: ParseOptions
+
+Defined in: [cache.ts:34](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L34)
+
+The options that every read of the pattern language takes.
+
+It is ONE field today, and it is an object rather than a positional argument so that a
+caller holds one object and hands it to every call — `parsePattern`, `buildPath`,
+`getCompiledPattern`, `findRouteByPath`, a route map and a bridge all take it, and
+`CompileOptions` and `RouteMapOptions` extend it with the caches of their own layer. A
+positional argument gave each layer a different position to remember.
+
+## Properties
+
+| Property                                           | Modifier   | Type                                                                     | Description                                                                                                              | Defined in                                                                                                     |
+| -------------------------------------------------- | ---------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| <a id="property-patterncache"></a> `patternCache?` | `readonly` | [`PatternCache`](PatternCache.md)\<[`ParsedPattern`](ParsedPattern.md)\> | The cache of the PARSE of a pattern. The default is the cache that this package shares with every caller of the process. | [cache.ts:40](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L40) |

package/api/@xmachines/play-pattern/interfaces/ParsedPattern.md

@@ -0,0 +1,23 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / ParsedPattern
+
+# Interface: ParsedPattern
+
+Defined in: [pattern-grammar.ts:117](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L117)
+
+Everything that this library reads from one route pattern.
+
+## Properties
+
+| Property                                            | Modifier   | Type                                                       | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | Defined in                                                                                                                           |
+| --------------------------------------------------- | ---------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| <a id="property-bareform"></a> `bareForm`           | `readonly` | `string` \| `null`                                         | The path that the pattern matches when every optional part is absent, or `null` when the pattern holds a part that a path must fill. `/settings/:section?` gives `/settings`, `/a/{b}?/c` gives `/a//c`, and `/profile/:userId` gives `null`.                                                                                                                                                                                                                                           | [pattern-grammar.ts:154](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L154) |
+| <a id="property-declarednames"></a> `declaredNames` | `readonly` | `ReadonlyMap`\<`string`, `string`\>                        | The map from each rewritten group name back to the name that the pattern declares, for example `cat_id` to `cat-id`. The map holds an entry only for a name that the rewrite changed. It is empty for most patterns, and a caller that reads a group name falls back to the name itself.                                                                                                                                                                                                | [pattern-grammar.ts:184](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L184) |
+| <a id="property-indexkey"></a> `indexKey`           | `readonly` | `string`                                                   | The key of the bucket index: the first path segment, or `"*"` when a param can stand in the first segment.                                                                                                                                                                                                                                                                                                                                                                              | [pattern-grammar.ts:171](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L171) |
+| <a id="property-literalpath"></a> `literalPath`     | `readonly` | `string` \| `null`                                         | The ONE path that the pattern matches, with each escape resolved, or `null` when the pattern describes a SET of paths. `/users` gives `/users`, `/tags/c\+\+` gives `/tags/c++`, `/x{y}z` gives `/xyz`, and `/profile/:userId` gives `null`. A bridge writes a real browser URL from this field. The SOURCE of the pattern is no substitute for it: `/tags/c\+\+` carries two backslashes that the address bar must not hold, and a location that carries them matches the route never. | [pattern-grammar.ts:166](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L166) |
+| <a id="property-names"></a> `names`                 | `readonly` | readonly `string`[]                                        | The name of every param of [params](#property-params), in the same order. `resolveFrameworkParams` runs on EVERY navigation and it needs this list each time. The parse holds it, so a navigation allocates none. A caller that hands the array to somebody else copies it: the cache holds this one.                                                                                                                                                                                   | [pattern-grammar.ts:131](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L131) |
+| <a id="property-normalized"></a> `normalized`       | `readonly` | `string`                                                   | The pattern in the form that URLPattern compiles: each param name that holds a hyphen carries an underscore instead.                                                                                                                                                                                                                                                                                                                                                                    | [pattern-grammar.ts:176](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L176) |
+| <a id="property-parameterized"></a> `parameterized` | `readonly` | `boolean`                                                  | True when the pattern needs a URLPattern match, and false when it is a literal path. A malformed pattern reports `true`, so that it reaches the URLPattern constructor and fails there with the error of the API. A parser that called it static would send it to the exact-match map instead, where it matches nothing and reports no fault.                                                                                                                                           | [pattern-grammar.ts:146](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L146) |
+| <a id="property-params"></a> `params`               | `readonly` | readonly [`PatternParam`](PatternParam.md)[]               | The NAMED params, in the order that the pattern declares them.                                                                                                                                                                                                                                                                                                                                                                                                                          | [pattern-grammar.ts:123](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L123) |
+| <a id="property-parts"></a> `parts`                 | `readonly` | readonly [`PatternPart`](../type-aliases/PatternPart.md)[] | The parts, in the order that the pattern declares them.                                                                                                                                                                                                                                                                                                                                                                                                                                 | [pattern-grammar.ts:121](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L121) |
+| <a id="property-requirednames"></a> `requiredNames` | `readonly` | readonly `string`[]                                        | The name of every param that a path must fill, in the order of [params](#property-params). The same rule as [names](#property-names): the parse holds the array, and a navigation reads it.                                                                                                                                                                                                                                                                                             | [pattern-grammar.ts:137](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L137) |
+| <a id="property-source"></a> `source`               | `readonly` | `string`                                                   | The pattern as the caller wrote it.                                                                                                                                                                                                                                                                                                                                                                                                                                                     | [pattern-grammar.ts:119](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L119) |

package/api/@xmachines/play-pattern/interfaces/PatternCache.md

@@ -0,0 +1,65 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PatternCache
+
+# Interface: PatternCache\<V\>
+
+Defined in: [cache.ts:53](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L53)
+
+What this package needs from a cache: a read and a write, both by a string key.
+
+The contract is this small on purpose. A `Map` satisfies it, and so does an LRU of any
+library — a caller that wants a time to live or an eviction callback brings the module
+that has one, and this package needs to know nothing about it.
+
+A cache may forget an entry at any time, and it may forget none. Both are correct: the
+parser runs again for an entry that is absent.
+
+## Type Parameters
+
+| Type Parameter |
+| -------------- |
+| `V`            |
+
+## Methods
+
+### get()
+
+```ts
+get(key): V | undefined;
+```
+
+Defined in: [cache.ts:55](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L55)
+
+Reads one entry, or `undefined` when the cache holds none for the key.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `key`     | `string` |
+
+#### Returns
+
+`V` \| `undefined`
+
+---
+
+### set()
+
+```ts
+set(key, value): void;
+```
+
+Defined in: [cache.ts:57](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/cache.ts#L57)
+
+Writes one entry.
+
+#### Parameters
+
+| Parameter | Type     |
+| --------- | -------- |
+| `key`     | `string` |
+| `value`   | `V`      |
+
+#### Returns
+
+`void`

package/api/@xmachines/play-pattern/interfaces/PatternParam.md

@@ -0,0 +1,15 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PatternParam
+
+# Interface: PatternParam
+
+Defined in: [pattern-grammar.ts:101](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L101)
+
+One named param of a pattern, with the question that every caller asks about it.
+
+## Properties
+
+| Property                                    | Modifier   | Type      | Description                                                                                                                                                                                                                                                           | Defined in                                                                                                                           |
+| ------------------------------------------- | ---------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
+| <a id="property-groupname"></a> `groupName` | `readonly` | `string`  | The name that URLPattern compiles, for example `cat_id`.                                                                                                                                                                                                              | [pattern-grammar.ts:105](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L105) |
+| <a id="property-name"></a> `name`           | `readonly` | `string`  | The name as the pattern declares it, for example `cat-id`.                                                                                                                                                                                                            | [pattern-grammar.ts:103](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L103) |
+| <a id="property-optional"></a> `optional`   | `readonly` | `boolean` | True when a matching path can carry no value for this param. The modifier `?` and the modifier `*` make a param optional, and so does EVERY group above it that carries one of the two. The modifier `+` does not: it repeats a param that one value must still fill. | [pattern-grammar.ts:113](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L113) |

package/api/@xmachines/play-pattern/type-aliases/PathBuildResult.md

@@ -0,0 +1,74 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PathBuildResult
+
+# Type Alias: PathBuildResult
+
+```ts
+type PathBuildResult =
+	| {
+			ok: true;
+			path: string;
+	  }
+	| {
+			missing: string;
+			ok: false;
+			reason: "missing";
+	  }
+	| {
+			ok: false;
+			param: string;
+			reason: "unresolvable";
+			value: string;
+	  };
+```
+
+Defined in: [pattern-grammar.ts:651](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L651)
+
+The answer of [buildPath](../functions/buildPath.md).
+
+## Union Members
+
+### Type Literal
+
+```ts
+{
+	ok: true;
+	path: string;
+}
+```
+
+The pattern built a path, and every part that needs a value has one.
+
+---
+
+### Type Literal
+
+```ts
+{
+	missing: string;
+	ok: false;
+	reason: "missing";
+}
+```
+
+A part needs a value that the caller did not give.
+
+`missing` names the param as the PATTERN declares it, with each hyphen kept, so a
+caller reports the name that its author wrote.
+
+---
+
+### Type Literal
+
+```ts
+{
+	ok: false;
+	param: string;
+	reason: "unresolvable";
+	value: string;
+}
+```
+
+A param carries a value that no path can hold, so the pattern matches the result
+back never. `param` names the param, and `value` holds what the caller gave.
+
+A dot segment is the one such value today: see [isDotSegment](../functions/isDotSegment.md).

package/api/@xmachines/play-pattern/type-aliases/PathParams.md

@@ -0,0 +1,15 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PathParams
+
+# Type Alias: PathParams
+
+```ts
+type PathParams = Readonly<Record<string, unknown>>;
+```
+
+Defined in: [pattern-grammar.ts:681](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L681)
+
+The values that a caller gives, keyed by the declared name of the param.
+
+The value is `unknown`, because a caller reads it from the context of an actor and that
+context carries whatever the machine put there. [buildPath](../functions/buildPath.md) calls `String` on a
+value that is neither `undefined` nor `null`.

package/api/@xmachines/play-pattern/type-aliases/PatternModifier.md

@@ -0,0 +1,11 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PatternModifier
+
+# Type Alias: PatternModifier
+
+```ts
+type PatternModifier = "" | "?" | "+" | "*";
+```
+
+Defined in: [pattern-grammar.ts:56](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L56)
+
+The modifier of a part. `""` means that the part carries none.

package/api/@xmachines/play-pattern/type-aliases/PatternPart.md

@@ -0,0 +1,9 @@
+[API](../../../README.md) / [@xmachines/play-pattern](../README.md) / PatternPart
+
+# Type Alias: PatternPart
+
+```ts
+type PatternPart = LiteralPart | ParamPart | GroupPart;
+```
+
+Defined in: [pattern-grammar.ts:98](https://gitlab.com/xmachin-es/xmachines-js/-/blob/v5.0.1/packages/play-pattern/src/pattern-grammar.ts#L98)