publish: bump version to v10.1.0

Author: sagold

README.md

@@ -114,8 +114,8 @@ console.log(titleNode.evaluationPath); // #/properties/image/properties/title
 console.log(titleNode.schemaLocation); // #/properties/image/properties/title
 ```
 
-- `evaluationPath` refers to the path in schema and is extended by `$ref`, e.g. if image is defined on `$defs`: `#/properties/image/$ref/properties/title`
-- `schemaLocation` refers to the absolute path within the schema and will not change, e.g. `#/$defs/properties/title`
+-   `evaluationPath` refers to the path in schema and is extended by `$ref`, e.g. if image is defined on `$defs`: `#/properties/image/$ref/properties/title`
+-   `schemaLocation` refers to the absolute path within the schema and will not change, e.g. `#/$defs/properties/title`
 
 </details>
 
@@ -163,17 +163,17 @@ _json-schema-library_ fully supports all core features of draft versions draft-0
 
 Draft support is defined by running a validator against the official [json-schema-test-suite](https://github.com/json-schema-org/JSON-Schema-Test-Suite).
 
-- Test results for _json-schema-library_ can be inspected in [github actions](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml)
-- A comparison to other validators is listed on [json-schema-benchmark](https://github.com/sagold/json-schema-benchmark)
+-   Test results for _json-schema-library_ can be inspected in [github actions](https://github.com/sagold/json-schema-library/actions/workflows/ci.yaml)
+-   A comparison to other validators is listed on [json-schema-benchmark](https://github.com/sagold/json-schema-benchmark)
 
 Please note that these benchmarks refer to validation only. _json-schema-library_ offers tooling outside of validation and strives to be as spec-compliant as possible.
 
 </details>
 
 <details><summary>Overview format validation support</summary>
 
-- **`❌ unsupported formats`** iri, iri-reference, idn-hostname
-- **`✅ supported formats`**: date, date-time, date, duration, ecmascript-regex, email, hostname, idn-email, ipv4, ipv6, json-pointer, regex, relative-json-pointer, time, unknown, uri-reference, uri-template, uri, uuid
+-   **`❌ unsupported formats`** iri, iri-reference, idn-hostname
+-   **`✅ supported formats`**: date, date-time, date, duration, ecmascript-regex, email, hostname, idn-email, ipv4, ipv6, json-pointer, regex, relative-json-pointer, time, unknown, uri-reference, uri-template, uri, uuid
 
 </details>
 
@@ -631,9 +631,9 @@ expect(node.schema).to.deep.equal({
 
 All returned json-errors have a data property with the following properties
 
-- `pointer` JSON Pointer to the location where the error occured. In case of omitted data, this is the last JSON Schema location that could be resolved
-- `schema` the JSON Schema of the last resolved location and the source of the error
-- `value` the data value at this location that could not be resolved
+-   `pointer` JSON Pointer to the location where the error occured. In case of omitted data, this is the last JSON Schema location that could be resolved
+-   `schema` the JSON Schema of the last resolved location and the source of the error
+-   `value` the data value at this location that could not be resolved
 
 ```ts
 const { error } = schemaNode.getNode("/list/1");
@@ -921,10 +921,10 @@ _json-schema-library_ uses the concept of **drafts** to support different versio
 
 Each **draft** describes how a schema should be parsed, validated, and interpreted. Drafts can also be extended or modified to change or enhance behavior, such as:
 
-- Replacing or adding new keywords (`oneOf`, `if/then`, custom ones, etc.)
-- Defining or overriding format validators (`format: "email"`, etc.)
-- Customizing or localizing error messages
-- Tweaking how schema nodes behave during parsing or resolution
+-   Replacing or adding new keywords (`oneOf`, `if/then`, custom ones, etc.)
+-   Defining or overriding format validators (`format: "email"`, etc.)
+-   Customizing or localizing error messages
+-   Tweaking how schema nodes behave during parsing or resolution
 
 Out of the box, the library exports all compliant JSON Schema drafts:
 
@@ -1123,10 +1123,10 @@ console.assert(valid, errors.at(0)?.message);
 
 **Keywords** hold the main logic for JSON Schema functionality. Each `Keyword` corresponds to a JSON Schema keyword like `properties`, `prefixItems`, `oneOf`, etc and offers implementations to `parse`, `validate`, `resolve` and `reduce`. Note that support for each implementation is optional, dependending on the feature requirements. The main properties of a `Keyword`:
 
-- a `Keyword` is only processed if the specified `keyword` is available as property on the JSON Schema
-- an optional `order` property may be added as order of keyword execution is sometimes important (`additionalItems` last, `$ref` evaluation first)
-- the list of keywords is unique by property-value `keyword`
-- for a given function `addX`, a function `X` must be present
+-   a `Keyword` is only processed if the specified `keyword` is available as property on the JSON Schema
+-   an optional `order` property may be added as order of keyword execution is sometimes important (`additionalItems` last, `$ref` evaluation first)
+-   the list of keywords is unique by property-value `keyword`
+-   for a given function `addX`, a function `X` must be present
 
 ```ts
 type Keyword = {
@@ -1294,6 +1294,11 @@ assert.deepEqual(errors[0].message, "Custom error 2");
 
 ## Breaking Changes
 
+### v10.1.0
+
+-   replaced `node.additionalItems` by `node.items` for drafts below 2020-12
+-   fixed `additionalItems` behaviour to be ignored when `schema.items` is not an array
+
 ### v10.0.0
 
 > This update involves some significant changes in how you work with the library, so please carefully review the migration guide and adjust your implementation accordingly.
@@ -1304,8 +1309,8 @@ The new implementation revolves around compiling schemas into a **SchemaNode** t
 
 #### Key Changes:
 
-- **Compile Schema**: The `compileSchema` function now replaces the previous Draft-Class approach.
-- **SchemaNode Representation**: All schemas are now represented as `SchemaNode`, which holds the schema and provides an easier way to work with them.
+-   **Compile Schema**: The `compileSchema` function now replaces the previous Draft-Class approach.
+-   **SchemaNode Representation**: All schemas are now represented as `SchemaNode`, which holds the schema and provides an easier way to work with them.
 
 #### Breaking Changes:
 
@@ -1321,14 +1326,14 @@ const node = compileSchema(schema);
 
 **Changed Methods**:
 
-- `draft.createSchemaOf(schema)` → `node.createSchema(schema)`
-- `draft.each(data, callback)` → `const nodes = node.toDataNodes(data)`
-- `draft.eachSchema(callback)` → `const nodes = node.toSchemaNodes()`
-- `draft.getChildSchemaSelection(property)` → `node.getChildSelection(property)`
-- `draft.getNode(options)` → `node.getNode(pointer, data, options)`
-- `draft.getTemplate(inputData)` → `node.getData(inputData)`
-- `draft.isValid(data)` → `node.validate(data).valid`
-- `draft.step(property, data)` → `node.getNodeChild(property, data)`
+-   `draft.createSchemaOf(schema)` → `node.createSchema(schema)`
+-   `draft.each(data, callback)` → `const nodes = node.toDataNodes(data)`
+-   `draft.eachSchema(callback)` → `const nodes = node.toSchemaNodes()`
+-   `draft.getChildSchemaSelection(property)` → `node.getChildSelection(property)`
+-   `draft.getNode(options)` → `node.getNode(pointer, data, options)`
+-   `draft.getTemplate(inputData)` → `node.getData(inputData)`
+-   `draft.isValid(data)` → `node.validate(data).valid`
+-   `draft.step(property, data)` → `node.getNodeChild(property, data)`
 
 **Renamed Properties**: `templateDefaultOptions` → `getDataDefaultOptions`
 
@@ -1354,28 +1359,28 @@ compileSchema(schema, {
 
 **breaking changes**:
 
-- _getSchema_ signature changed in favour of an options object. Instead of `draft.getNode(pointer, data)` arguments have to be passed as an object `draft.getNode({ pointer, data })`. This removes setting unwanted optional arguments and keeps the api more stable in the future (e.g. `withSchemaWarning` option)
-- _JsonError_ now must expose `pointer`, `schema` and `value` consistently on data property
+-   _getSchema_ signature changed in favour of an options object. Instead of `draft.getNode(pointer, data)` arguments have to be passed as an object `draft.getNode({ pointer, data })`. This removes setting unwanted optional arguments and keeps the api more stable in the future (e.g. `withSchemaWarning` option)
+-   _JsonError_ now must expose `pointer`, `schema` and `value` consistently on data property
 
 **updates**
 
-- _getSchema_ consistently returns errors and can return errors for empty schema using `withSchemaWarning` option
+-   _getSchema_ consistently returns errors and can return errors for empty schema using `withSchemaWarning` option
 
 ### v8.0.0
 
 With version `v8.0.0`, _getData_ was improved to better support optional properties and utilize existing core logic, making it more reliable. Breaking changes:
 
-- Renamed `JSONError` to `JsonError` and `JSONSchema` to `JsonSchema`
-- `getData` only adds required properties. Behaviour can be changed by [getData default options](#getData-default-options)
-- Internal schema property `oneOfSchema` has been replaced by `schema.getOneOfOrigin()`
-- Changed `unique-items-error` to point to error for duplicated item and changed data-properties
-- Removed `SchemaService` as it was no longer used nor tested
+-   Renamed `JSONError` to `JsonError` and `JSONSchema` to `JsonSchema`
+-   `getData` only adds required properties. Behaviour can be changed by [getData default options](#getData-default-options)
+-   Internal schema property `oneOfSchema` has been replaced by `schema.getOneOfOrigin()`
+-   Changed `unique-items-error` to point to error for duplicated item and changed data-properties
+-   Removed `SchemaService` as it was no longer used nor tested
 
 <details><summary>Exposed new helper functions</summary>
 
-- `mergeSchema` - Merges to two json schema
-- `reduceNode` - Reduce schema by merging dynamic constructs into a static json schema omitting those properties
-- `isDynamicSchema` - Returns true if the passed schema contains dynamic properties (_if_, _dependencies_, _allOf_, etc)
-- `resolveDynamicSchema` - Resolves all dynamic schema definitions for the given input data and returns the resulting JSON Schema without any dynamic schema definitions.
+-   `mergeSchema` - Merges to two json schema
+-   `reduceNode` - Reduce schema by merging dynamic constructs into a static json schema omitting those properties
+-   `isDynamicSchema` - Returns true if the passed schema contains dynamic properties (_if_, _dependencies_, _allOf_, etc)
+-   `resolveDynamicSchema` - Resolves all dynamic schema definitions for the given input data and returns the resulting JSON Schema without any dynamic schema definitions.
 
 </details>

dist/jsonSchemaLibrary.js

@@ -6,26 +6,23 @@ export const additionalItemsKeyword = {
     keyword: "additionalItems",
     order: -10,
     parse: parseAdditionalItems,
-    addResolve: (node) => node.additionalItems != null,
+    addResolve: (node) => node.items != null,
     resolve: additionalItemsResolver,
-    addValidate: ({ schema }) => schema.additionalItems != null &&
-        schema.additionalItems !== true &&
-        schema.items != null &&
-        !isObject(schema.items),
+    addValidate: ({ schema }) => schema.additionalItems != null && schema.additionalItems !== true && Array.isArray(schema.items),
     validate: validateAdditionalItems
 };
 // must come as last resolver
 export function parseAdditionalItems(node) {
     const { schema, evaluationPath, schemaLocation } = node;
-    if (isObject(schema.additionalItems) || schema.additionalItems === true) {
-        node.additionalItems = node.compileSchema(schema.additionalItems, `${evaluationPath}/additionalItems`, `${schemaLocation}/additionalItems`);
+    if ((isObject(schema.additionalItems) || schema.additionalItems === true) && Array.isArray(schema.items)) {
+        node.items = node.compileSchema(schema.additionalItems, `${evaluationPath}/additionalItems`, `${schemaLocation}/additionalItems`);
     }
 }
 function additionalItemsResolver({ node, key, data }) {
     if (Array.isArray(data)) {
         // @attention: items, etc should already have been tried
         const value = getValue(data, key);
-        const { node: childNode, error } = node.additionalItems.reduceNode(value);
+        const { node: childNode, error } = node.items.reduceNode(value);
         return childNode !== null && childNode !== void 0 ? childNode : error;
     }
 }
@@ -43,8 +40,8 @@ function validateAdditionalItems({ node, data, pointer, path }) {
     const errors = [];
     for (let i = startIndex; i < data.length; i += 1) {
         const item = data[i];
-        if (node.additionalItems) {
-            const validationResult = validateNode(node.additionalItems, item, `${pointer}/${i}`, path);
+        if (node.items) {
+            const validationResult = validateNode(node.items, item, `${pointer}/${i}`, path);
             validationResult && errors.push(...validationResult);
         }
         else if (schema.additionalItems === false) {

dist/module/src/draft2019-09/keywords/additionalItems.js

@@ -10,12 +10,13 @@ export const itemsKeyword = {
     validate: validateItems
 };
 function itemsResolver({ node, key }) {
+    var _a;
+    if ((_a = node.prefixItems) === null || _a === void 0 ? void 0 : _a[key]) {
+        return node.prefixItems[key];
+    }
     if (node.items) {
         return node.items;
     }
-    if (node.prefixItems[key]) {
-        return node.prefixItems[key];
-    }
 }
 export function parseItems(node) {
     const { schema, evaluationPath } = node;

dist/module/src/draft2019-09/keywords/items.js

@@ -20,13 +20,12 @@ export function getChildSelection(node, property) {
         return error;
     }
     // array.items[] exceeded (or undefined), but additionalItems specified
-    if (node.additionalItems && node.items == null) {
+    if (node.schema.additionalItems) {
         // we fallback to a string if no schema is defined - might be subject for configuration
-        // @ts-expect-error boolean schema
-        if (node.additionalItems.schema === true) {
+        if (node.schema.additionalItems === true) {
             return [node.compileSchema({ type: "string" })];
         }
-        return [node.additionalItems.resolveRef()];
+        return [node.items.resolveRef()];
     }
     // array.items[] exceeded
     if (node.prefixItems && node.prefixItems.length <= +property) {

dist/module/src/draft2019-09/methods/getChildSelection.js

@@ -232,10 +232,10 @@ const TYPE = {
         // when there are no array-items are defined
         if (schema.items == null) {
             // => all items are additionalItems
-            if (node.additionalItems) {
+            if (node.items) {
                 const itemCount = Math.max(minItems, d.length);
                 for (let i = 0; i < itemCount; i += 1) {
-                    d[i] = node.additionalItems.getData(d[i], opts);
+                    d[i] = node.items.getData(d[i], opts);
                 }
             }
             return d || [];
@@ -246,7 +246,7 @@ const TYPE = {
             // build defined set of items
             const length = Math.max(minItems !== null && minItems !== void 0 ? minItems : 0, node.prefixItems.length);
             for (let i = 0; i < length; i += 1) {
-                const childNode = (_b = node.prefixItems[i]) !== null && _b !== void 0 ? _b : node.additionalItems;
+                const childNode = (_b = node.prefixItems[i]) !== null && _b !== void 0 ? _b : node.items;
                 if ((childNode && canResolveRef(childNode, opts)) || input[i] !== undefined) {
                     const result = childNode.getData(d[i] == null ? template[i] : d[i], opts);
                     if (result !== undefined) {
@@ -261,8 +261,7 @@ const TYPE = {
             return d;
         }
         // build data from items-definition
-        // @ts-expect-error asd
-        if ((node.items && canResolveRef(node.items, opts)) || (data === null || data === void 0 ? void 0 : data.length) > 0) {
+        if ((node.items && canResolveRef(node.items, opts)) || (Array.isArray(data) && (data === null || data === void 0 ? void 0 : data.length) > 0)) {
             // @attention this should disable cache or break intended behaviour as we reset it after loop
             // intention: reset cache after each property. last call will add counters
             const cache = { ...opts.cache };

dist/module/src/draft2019-09/methods/getData.js

@@ -77,7 +77,6 @@ export function mergeNode(a, b, ...omit) {
         resolvers: a.resolvers.concat(b.resolvers).filter(removeDuplicates).sort(sortCb),
         reducers: a.reducers.concat(b.reducers).filter(removeDuplicates).sort(sortCb),
         validators: a.validators.concat(b.validators).filter(removeDuplicates).sort(sortCb),
-        additionalItems: mergeNode(a.additionalItems, b.additionalItems),
         additionalProperties: mergeNode(a.additionalProperties, b.additionalProperties),
         contains: mergeNode(a.contains, b.contains),
         if: mergeNode(a.if, b.if),

dist/module/src/mergeNode.js

@@ -15,7 +15,6 @@ export function toSchemaNodes(node, nodeList = []) {
     }
     nodeList.push(node);
     eachProperty(nodeList, node.$defs);
-    node.additionalItems && toSchemaNodes(node.additionalItems, nodeList);
     node.additionalProperties && toSchemaNodes(node.additionalProperties, nodeList);
     eachItem(nodeList, node.allOf);
     eachItem(nodeList, node.anyOf);

dist/module/src/methods/toSchemaNodes.js

@@ -75,8 +75,6 @@ export interface SchemaNode extends SchemaNodeMethodsType {
     $id?: string;
     $defs?: Record<string, SchemaNode>;
     $ref?: string;
-    /** only used for draft <= 2019-09 */
-    additionalItems?: SchemaNode;
     additionalProperties?: SchemaNode;
     allOf?: SchemaNode[];
     anyOf?: SchemaNode[];
@@ -85,7 +83,40 @@ export interface SchemaNode extends SchemaNodeMethodsType {
     dependentSchemas?: Record<string, SchemaNode | boolean>;
     else?: SchemaNode;
     if?: SchemaNode;
+    /**
+     * # Items-array schema - for all drafts
+     *
+     * - for drafts prior 2020-12 `schema.items[]`-schema stored as `node.prefixItems`
+     *
+     * Validation succeeds if each element of the instance validates against the schema at the
+     * same position, if any.
+     *
+     * The `prefixItems` keyword restricts a number of items from the start of an array instance
+     * to validate against the given sequence of subschemas, where the item at a given index in
+     * the array instance is evaluated against the subschema at the given index in the `prefixItems`
+     * array, if any. Array items outside the range described by the `prefixItems` keyword is
+     * evaluated against the items keyword, if present.
+     *
+     * [Docs](https://www.learnjsonschema.com/2020-12/applicator/prefixitems/)
+     * | [Examples](https://json-schema.org/understanding-json-schema/reference/array#tupleValidation)
+     */
     prefixItems?: SchemaNode[];
+    /**
+     * # Items-object schema for additional array item - for all drafts
+     *
+     * - for drafts prior 2020-12 `schema.additionalItems` object-schema stored as `node.items`
+     *
+     * Validation succeeds if each element of the instance not covered by `prefixItems` validates
+     * against this schema.
+     *
+     * The items keyword restricts array instance items not described by the sibling `prefixItems`
+     * keyword (if any), to validate against the given subschema. Whetherthis keyword was evaluated
+     * against any item of the array instance is reported using annotations.
+     *
+     * [Docs](https://www.learnjsonschema.com/2020-12/applicator/items/)
+     * | [Examples](https://json-schema.org/understanding-json-schema/reference/array#items)
+     * | [AdditionalItems Specification](https://json-schema.org/draft/2019-09/draft-handrews-json-schema-02#additionalItems)
+     */
     items?: SchemaNode;
     not?: SchemaNode;
     oneOf?: SchemaNode[];

dist/src/SchemaNode.d.ts

@@ -1,6 +1,6 @@
 {
     "name": "json-schema-library",
-    "version": "10.0.0",
+    "version": "10.1.0",
     "description": "Customizable and hackable json-validator and json-schema utilities for traversal, data generation and validation",
     "module": "dist/module/index.js",
     "types": "dist/index.d.ts",