@satisfactory-dev/docs.json.ts 0.10.1 → 0.11.1

package/lib/CustomParsingTypes/UnrealEngineString.d.ts

@@ -2,7 +2,8 @@ import Ajv from 'ajv/dist/2020';
 import ts, { StringLiteral, TypeNode, TypeReferenceNode, UnionTypeNode } from 'typescript';
 import { entry } from '../FilesGenerator';
 export declare const UnrealEngineString_regex: RegExp;
-export declare const UnrealEngineString_general_regex = "/(?:[A-Z-][A-Za-z0-9_-]+/)+(?:[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z][A-Za-z_]+\\.[A-Z][A-Za-z_]+)";
+export declare const UnrealEngineString_regex_quoted: RegExp;
+export declare const UnrealEngineString_general_regex = "/(?:[A-Z-][A-Za-z0-9_-]+/)+(?:[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z0-9][A-Za-z_]+\\.[A-Z0-9][A-Za-z_]+)";
 export type UnrealEngineString_string_or_string_array = string | [string, ...string[]];
 export declare function string_or_string_array_to_node(value: string | [string, ...string[]]): typeof value extends string ? (ts.LiteralTypeNode & {
     literal: StringLiteral;
@@ -13,11 +14,14 @@ export type UnrealEngineString_right = UnrealEngineString_string_or_string_array
 export type UnrealEngineString_type = {
     left: UnrealEngineString_string_or_string_array;
     right: UnrealEngineString_right;
+    quote_mode?: typeof UnrealEngineString['quote_mode'];
 } | {
     left: UnrealEngineString_string_or_string_array;
+    quote_mode?: typeof UnrealEngineString['quote_mode'];
 } | {
     right: UnrealEngineString_right;
-} | true;
+    quote_mode?: typeof UnrealEngineString['quote_mode'];
+} | typeof UnrealEngineString['quote_mode'] | true;
 export type UnrealEngineString_parent_type = {
     type: 'string';
     minLength: 1;
@@ -97,6 +101,10 @@ export declare const UnrealEngineString_schema_definitions: {
             items?: undefined;
         })[];
     };
+    UnrealEngineString_quote_mode: {
+        type: string;
+        enum: string[];
+    };
 };
 export declare const UnrealEngineString_schema: {
     oneOf: ({
@@ -110,7 +118,11 @@ export declare const UnrealEngineString_schema: {
             right: {
                 $ref: "#/$defs/UnrealEngineString_right";
             };
+            quote_mode: {
+                $ref: "#/$defs/UnrealEngineString_quote_mode";
+            };
         };
+        $ref?: undefined;
         const?: undefined;
     } | {
         type: string;
@@ -120,8 +132,12 @@ export declare const UnrealEngineString_schema: {
             left: {
                 $ref: "#/$defs/UnrealEngineString_left";
             };
+            quote_mode: {
+                $ref: "#/$defs/UnrealEngineString_quote_mode";
+            };
             right?: undefined;
         };
+        $ref?: undefined;
         const?: undefined;
     } | {
         type: string;
@@ -131,8 +147,19 @@ export declare const UnrealEngineString_schema: {
             right: {
                 $ref: "#/$defs/UnrealEngineString_right";
             };
+            quote_mode: {
+                $ref: "#/$defs/UnrealEngineString_quote_mode";
+            };
             left?: undefined;
         };
+        $ref?: undefined;
+        const?: undefined;
+    } | {
+        $ref: "#/$defs/UnrealEngineString_quote_mode";
+        type?: undefined;
+        required?: undefined;
+        additionalProperties?: undefined;
+        properties?: undefined;
         const?: undefined;
     } | {
         type: string;
@@ -140,6 +167,7 @@ export declare const UnrealEngineString_schema: {
         required?: undefined;
         additionalProperties?: undefined;
         properties?: undefined;
+        $ref?: undefined;
     })[];
 };
 export declare const UnrealEngineString_parent_schema: {
@@ -167,7 +195,11 @@ export declare const UnrealEngineString_parent_schema: {
                     right: {
                         $ref: "#/$defs/UnrealEngineString_right";
                     };
+                    quote_mode: {
+                        $ref: "#/$defs/UnrealEngineString_quote_mode";
+                    };
                 };
+                $ref?: undefined;
                 const?: undefined;
             } | {
                 type: string;
@@ -177,8 +209,12 @@ export declare const UnrealEngineString_parent_schema: {
                     left: {
                         $ref: "#/$defs/UnrealEngineString_left";
                     };
+                    quote_mode: {
+                        $ref: "#/$defs/UnrealEngineString_quote_mode";
+                    };
                     right?: undefined;
                 };
+                $ref?: undefined;
                 const?: undefined;
             } | {
                 type: string;
@@ -188,8 +224,19 @@ export declare const UnrealEngineString_parent_schema: {
                     right: {
                         $ref: "#/$defs/UnrealEngineString_right";
                     };
+                    quote_mode: {
+                        $ref: "#/$defs/UnrealEngineString_quote_mode";
+                    };
                     left?: undefined;
                 };
+                $ref?: undefined;
+                const?: undefined;
+            } | {
+                $ref: "#/$defs/UnrealEngineString_quote_mode";
+                type?: undefined;
+                required?: undefined;
+                additionalProperties?: undefined;
+                properties?: undefined;
                 const?: undefined;
             } | {
                 type: string;
@@ -197,6 +244,7 @@ export declare const UnrealEngineString_parent_schema: {
                 required?: undefined;
                 additionalProperties?: undefined;
                 properties?: undefined;
+                $ref?: undefined;
             })[];
         };
     };
@@ -204,6 +252,7 @@ export declare const UnrealEngineString_parent_schema: {
 export declare const UnrealEngineString_left_default: string[];
 export declare class UnrealEngineString {
     private static already_configured;
+    static quote_mode: 'both' | 'original' | 'new' | 'double_escaped' | 'double';
     static ajv_macro_generator(inner: boolean): (data_from_schema: UnrealEngineString_type) => {
         pattern: string;
     };

package/lib/CustomParsingTypes/UnrealEngineString.js

@@ -3,7 +3,9 @@ import { is_string, object_has_property, value_is_non_array_object, } from '@sat
 import { adjust_class_name, create_const_statement, create_index_access, create_literal, create_method_with_type_parameters, create_method_without_type_parameters, create_modifiers, create_property_access, create_this_assignment, create_throw_if, create_type, createClass, createParameter, not, parenthesize, possibly_create_lazy_union, template_expression_from_string, type_reference_node, variable, } from '../TsFactoryWrapper';
 import { local_ref, } from '../StringStartsWith';
 export const UnrealEngineString_regex = /^([^']+)'(?:"([^"]+)"|([^"]+))'$/;
-export const UnrealEngineString_general_regex = `/(?:[A-Z-][A-Za-z0-9_-]+/)+(?:[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z][A-Za-z_]+\\.[A-Z][A-Za-z_]+)`;
+// eslint-disable-next-line max-len
+export const UnrealEngineString_regex_quoted = /^"([^']+)'(?:"([^"]+)"|([^"]+))'"$/;
+export const UnrealEngineString_general_regex = `/(?:[A-Z-][A-Za-z0-9_-]+/)+(?:[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z0-9][A-Za-z_]+\\.[A-Z0-9][A-Za-z_]+)`;
 export function string_or_string_array_to_node(value) {
     if (is_string(value)) {
         return create_literal(value);
@@ -19,7 +21,15 @@ export function is_UnrealEngineString_parent(maybe) {
         && 1 === maybe.minLength
         && object_has_property(maybe, 'UnrealEngineString')
         && (true === maybe.UnrealEngineString
-            || is_UnrealEngineString_object(maybe.UnrealEngineString)));
+            || is_UnrealEngineString_object(maybe.UnrealEngineString)
+            || (is_string(maybe.UnrealEngineString)
+                && [
+                    'original',
+                    'new',
+                    'double_escaped',
+                    'double',
+                    'both',
+                ].includes(maybe.UnrealEngineString))));
 }
 export const UnrealEngineString_schema_definitions = {
     UnrealEngineString_left_string: {
@@ -77,6 +87,16 @@ export const UnrealEngineString_schema_definitions = {
                         ] } },
             },
         ] },
+    UnrealEngineString_quote_mode: {
+        type: 'string',
+        enum: [
+            'original',
+            'both',
+            'double_escaped',
+            'double',
+            'new',
+        ],
+    },
 };
 export const UnrealEngineString_schema = {
     oneOf: [
@@ -91,6 +111,9 @@ export const UnrealEngineString_schema = {
                 right: {
                     $ref: local_ref('UnrealEngineString_right'),
                 },
+                quote_mode: {
+                    $ref: local_ref('UnrealEngineString_quote_mode'),
+                },
             },
         },
         {
@@ -101,6 +124,9 @@ export const UnrealEngineString_schema = {
                 left: {
                     $ref: local_ref('UnrealEngineString_left'),
                 },
+                quote_mode: {
+                    $ref: local_ref('UnrealEngineString_quote_mode'),
+                },
             },
         },
         {
@@ -111,8 +137,14 @@ export const UnrealEngineString_schema = {
                 right: {
                     $ref: local_ref('UnrealEngineString_right'),
                 },
+                quote_mode: {
+                    $ref: local_ref('UnrealEngineString_quote_mode'),
+                },
             },
         },
+        {
+            $ref: local_ref('UnrealEngineString_quote_mode'),
+        },
         {
             type: 'boolean',
             const: true,
@@ -132,12 +164,17 @@ export const UnrealEngineString_parent_schema = {
 export const UnrealEngineString_left_default = [
     '/Script/Engine.BlueprintGeneratedClass',
 ];
-const right_value_starts_with_suffix = '(?:[A-Z][A-Za-z0-9_.]+/)*[A-Z][A-Za-z_.0-9-]+(?::[A-Z][A-Za-z0-9]+)?';
+const right_value_starts_with_suffix = 
+// eslint-disable-next-line max-len
+'(?:_?[A-Z0-9][A-Za-z0-9_.]+/)*[A-Z0-9][A-Za-z_.0-9-]+(?::[A-Z0-9][A-Za-z0-9]+)?';
 export class UnrealEngineString {
     static already_configured = new WeakSet();
+    // eslint-disable-next-line max-len
+    static quote_mode = 'both';
     static ajv_macro_generator(inner) {
         return (data_from_schema) => {
-            const data = true === data_from_schema ? {} : data_from_schema;
+            const data = (true === data_from_schema
+                || is_string(data_from_schema)) ? {} : data_from_schema;
             const left_value = ('left' in data
                 ? data.left instanceof Array
                     ? data.left
@@ -157,7 +194,26 @@ export class UnrealEngineString {
                                 .join('|')})`,
                     ]).join('|')})`
                 : UnrealEngineString_general_regex;
-            const regex = `(?:(?:${left_value})'(?:${right_value}|"${right_value}")')`;
+            let regex = `(?:(?:${left_value})'(?:${right_value}|"${right_value}")'|"(?:${left_value})'${right_value}'"|\\\\"(?:${left_value})'${right_value}'\\\\")`;
+            let quote_mode = this.quote_mode;
+            if (is_string(data_from_schema)) {
+                quote_mode = data_from_schema;
+            }
+            else if ('quote_mode' in data && undefined !== data.quote_mode) {
+                quote_mode = data.quote_mode;
+            }
+            if ('original' === quote_mode) {
+                regex = `(?:(?:${left_value})'(?:${right_value}|"${right_value}")')`;
+            }
+            else if ('new' === quote_mode) {
+                regex = `(?:"(?:${left_value})'${right_value}'"|\\\\"(?:${left_value})'${right_value}'\\\\")`;
+            }
+            else if ('double_escaped' === quote_mode) {
+                regex = `(?:\\\\"(?:${left_value})'${right_value}'\\\\")`;
+            }
+            else if ('double' === quote_mode) {
+                regex = `(?:"(?:${left_value})'${right_value}'")`;
+            }
             return {
                 pattern: inner ? regex : `^${regex}$`,
             };
@@ -301,6 +357,17 @@ function is_UnrealEngineString_object(maybe) {
                 && 1 === Object.keys(maybe.right).length
                 && is_string_or_string_array(maybe.right.starts_with)
             : is_string_or_string_array(maybe.right));
-    return ((2 === keys.length && has_left && has_right)
+    const has_quote_mode = ('quote_mode' in maybe
+        && is_string(maybe.quote_mode)
+        && [
+            'original',
+            'double_escaped',
+            'double',
+            'both',
+            'new',
+        ].includes(maybe.quote_mode));
+    return ((3 === keys.length && has_left && has_right && has_quote_mode)
+        || (2 === keys.length && has_left && has_right)
+        || (2 === keys.length && has_quote_mode && (has_left || has_right))
         || (1 === keys.length && (has_left || has_right)));
 }

package/lib/CustomParsingTypes/ValueToRegexFormatter.d.ts

@@ -24,6 +24,7 @@ export declare class ValueToRegexFormatter {
     private static is_typed_string_array_inner;
     private static is_typed_string_array_prefixItems;
     private static is_typed_string_object_inner;
+    private static is_typed_string_object_inner_no_required;
     private static is_typed_string_object_parent;
     private static is_typed_string_object_pattern_inner;
 }

package/lib/CustomParsingTypes/ValueToRegexFormatter.js

@@ -68,14 +68,14 @@ export class ValueToRegexFormatter {
         const regex = this.value_to_regex(typed_string_array.items);
         return `\\(${regex}${undefined === typed_string_array.minItems
             ? ''
-            : `(?:,${regex}){${typed_string_array.minItems - 1},}`}\\)`;
+            : `(?:, ?${regex}){${typed_string_array.minItems - 1},}`}\\)`;
     }
     typed_string_object_inner_to_regex(typed_string_object) {
         return `\\(${Object.entries(typed_string_object.properties).map((entry, index) => {
             const [property, value] = entry;
-            return `(?:${index > 0
-                ? ','
-                : ''}${annoyingly_have_to_escape_property(property)}=(?:${this.value_to_regex(value)}))${typed_string_object.required.includes(property)
+            return `(?:(?:${index > 0
+                ? ',?'
+                : ''}${annoyingly_have_to_escape_property(property)})=(?:${this.value_to_regex(value)}))${(typed_string_object?.required || []).includes(property)
                 ? ''
                 : '?'}`;
         }).join('')}\\)`;
@@ -86,7 +86,8 @@ export class ValueToRegexFormatter {
         return `\\(${regex}(,${regex}){${typed_string_object.minProperties - 1},}\\)`;
     }
     value_to_regex(value) {
-        if (ValueToRegexFormatter.is_typed_string_object_inner(value)) {
+        if (ValueToRegexFormatter.is_typed_string_object_inner(value)
+            || ValueToRegexFormatter.is_typed_string_object_inner_no_required(value)) {
             return this.typed_string_object_inner_to_regex(value);
         }
         else if (ValueToRegexFormatter.is_typed_string_object_pattern_inner(value)) {
@@ -189,13 +190,18 @@ export class ValueToRegexFormatter {
             && object_has_property(maybe, 'properties', value_is_non_array_object)
             && 2 === Object.keys(maybe).length);
     }
+    static is_typed_string_object_inner_no_required(maybe) {
+        return (object_has_property(maybe, 'properties', value_is_non_array_object)
+            && 1 === Object.keys(maybe).length);
+    }
     static is_typed_string_object_parent(maybe) {
         return (object_has_property_that_equals(maybe, 'type', 'string')
             && object_has_property_that_equals(maybe, 'minLength', 1)
             && object_has_property(maybe, 'typed_string')
             && 3 === Object.keys(maybe).length
             && (this.is_typed_string_object_inner(maybe.typed_string)
-                || this.is_typed_string_array_inner(maybe.typed_string)));
+                || this.is_typed_string_array_inner(maybe.typed_string)
+                || this.is_typed_string_object_inner_no_required(maybe.typed_string)));
     }
     static is_typed_string_object_pattern_inner(maybe) {
         return (object_has_property(maybe, 'minProperties', is_number)

package/lib/DataDiscovery/CustomTypes/TypedString.js

@@ -34,13 +34,21 @@ export class TypedStringConverter extends ConverterMatchesSchema {
                     && ((typed_string.is_array_type(schema.typed_string)
                         && this.check_shallow_array_schema(schema.typed_string, string_to_array(raw_data, true)))
                         || (typed_string.is_prefixItems_type(schema.typed_string)
-                            && this.check_shallow_array_prefixItems_schema(schema.typed_string, string_to_array(raw_data, true)))))));
+                            && this.check_shallow_array_prefixItems_schema(schema.typed_string, string_to_array(raw_data, true)))))
+                || (!('required' in schema.typed_string)
+                    && ('properties' in schema.typed_string)
+                    && typed_string.is_object_type(schema.typed_string))));
     }
     async convert(schema, raw_data) {
         if (!await this.can_convert_schema_and_raw_data(schema, raw_data)) {
             throw new NoMatchError({
                 schema,
                 raw_data,
+                can_convert: this.can_convert_schema(schema),
+                is_string: is_string(raw_data),
+                is_array_type: typed_string.is_array_type(schema.typed_string),
+                string_to_array: string_to_array(raw_data),
+                shallow: (typed_string.is_array_type(schema.typed_string) && this.check_shallow_array_schema(schema.typed_string, string_to_array(raw_data))),
             }, 'Cannot convert!');
         }
         else if (typed_string.is_object_type(schema.typed_string)

package/lib/DataDiscovery/CustomTypes/UnrealEngineString.js

@@ -1,6 +1,6 @@
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import { Converter, ExpressionResult, } from '../Generator';
-import { is_UnrealEngineString_parent, string_or_string_array_to_node, UnrealEngineString_regex, } from '../../CustomParsingTypes/UnrealEngineString';
+import { is_UnrealEngineString_parent, string_or_string_array_to_node, UnrealEngineString_regex, UnrealEngineString_regex_quoted, } from '../../CustomParsingTypes/UnrealEngineString';
 import ts from 'typescript';
 import { create_literal, create_property_access, create_type, type_reference_node, } from '../../TsFactoryWrapper';
 import { NoMatchError, } from '../../Exceptions';
@@ -11,13 +11,20 @@ export class UnrealEngineStringConverter extends Converter {
     can_convert_schema_and_raw_data(schema, raw_data) {
         return Promise.resolve(this.can_convert_schema(schema)
             && is_string(raw_data)
-            && UnrealEngineString_regex.test(raw_data));
+            && (UnrealEngineString_regex.test(raw_data)
+                || UnrealEngineString_regex_quoted.test(raw_data)));
     }
     async convert(schema, raw_data) {
         if (!await this.can_convert_schema_and_raw_data(schema, raw_data)) {
             throw new NoMatchError({
                 schema,
                 raw_data,
+                can_convert: this.can_convert_schema(schema),
+                is_string: is_string(raw_data),
+                regex: UnrealEngineString_regex,
+                regex_quoted: UnrealEngineString_regex_quoted,
+                test_regex: UnrealEngineString_regex.test(raw_data),
+                test_regex_quoted: UnrealEngineString_regex_quoted.test(raw_data),
             }, 'Not an UnrealEngineString!');
         }
         const type_args = [

package/lib/DataDiscovery/JsonSchema/Array.d.ts

@@ -8,10 +8,18 @@ type array_type = {
     minItems: number;
     maxItems?: number;
 };
-export declare class ArrayConverter extends ConverterMatchesSchema<array_type, unknown[], ArrayLiteralExpression> {
+type prefix_array_type = {
+    type: 'array';
+    items?: false;
+    prefixItems: [SchemaObject, ...SchemaObject[]];
+    minItems: number;
+    maxItems?: number;
+};
+export declare class ArrayConverter extends ConverterMatchesSchema<array_type | prefix_array_type, unknown[], ArrayLiteralExpression> {
+    #private;
     private readonly discovery;
     constructor(discovery: DataDiscovery);
     can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
-    convert(schema: array_type, raw_data: unknown[]): Promise<ExpressionResult<ArrayLiteralExpression>>;
+    convert(schema: array_type | prefix_array_type, raw_data: unknown[]): Promise<ExpressionResult<ArrayLiteralExpression>>;
 }
 export {};

package/lib/DataDiscovery/JsonSchema/Array.js

@@ -4,23 +4,45 @@ export class ArrayConverter extends ConverterMatchesSchema {
     discovery;
     constructor(discovery) {
         super(discovery.docs.ajv, {
-            type: 'object',
-            required: ['type', 'minItems', 'items'],
-            additionalProperties: false,
-            properties: {
-                type: { type: 'string', const: 'array' },
-                items: { type: 'object' },
-                minItems: { type: 'number', minimum: 0 },
-                maxItems: { type: 'number', minimum: 1 },
-            },
+            oneOf: [
+                {
+                    type: 'object',
+                    required: ['type', 'minItems', 'items'],
+                    additionalProperties: false,
+                    properties: {
+                        type: { type: 'string', const: 'array' },
+                        items: { type: 'object' },
+                        minItems: { type: 'number', minimum: 0 },
+                        maxItems: { type: 'number', minimum: 1 },
+                    },
+                },
+                {
+                    type: 'object',
+                    required: ['type', 'minItems', 'prefixItems'],
+                    additionalProperties: false,
+                    properties: {
+                        type: { type: 'string', const: 'array' },
+                        items: { type: 'boolean', const: false },
+                        prefixItems: { type: 'array', items: {
+                                type: 'object',
+                            } },
+                        minItems: { type: 'number', minimum: 0 },
+                        maxItems: { type: 'number', minimum: 1 },
+                    },
+                },
+            ],
         });
         this.discovery = discovery;
     }
     async can_convert_schema_and_raw_data(schema, raw_data) {
         return Promise.resolve(this.can_convert_schema(schema)
             && raw_data instanceof Array
-            && !!((await this.discovery.candidates).find(e => e.can_convert_schema(schema.items)))
-            && !!Converter.has_matching_schema(await this.discovery.candidates, schema.items));
+            && ((!('prefixItems' in schema)
+                && !!((await this.discovery.candidates).find(e => e.can_convert_schema(schema.items)))
+                && !!Converter.has_matching_schema(await this.discovery.candidates, schema.items))
+                || (('prefixItems' in schema)
+                    && !!await Promise.all(schema.prefixItems.map(async (sub_schema) => (!!(await this.discovery.candidates).find(e => e.can_convert_schema(sub_schema))
+                        && !!Converter.has_matching_schema(await this.discovery.candidates, sub_schema)))))));
     }
     async convert(schema, raw_data) {
         if (!this.can_convert_schema(schema)
@@ -30,11 +52,33 @@ export class ArrayConverter extends ConverterMatchesSchema {
                 raw_data,
             }, 'Cannot convert!');
         }
+        const converted = 'prefixItems' in schema
+            ? await this.#convert_prefixItems_type(schema, raw_data)
+            : await this.#convert_array_type(schema, raw_data);
+        return new ExpressionResult(await this.discovery.literal.array_literal(converted));
+    }
+    async #convert_array_type(schema, raw_data) {
         const converter = await Converter.find_matching_schema(await this.discovery.candidates, schema.items);
         const converted = [];
         for (const entry of raw_data) {
             converted.push(await converter.convert(schema.items, entry));
         }
-        return new ExpressionResult(await this.discovery.literal.array_literal(converted));
+        return converted;
+    }
+    async #convert_prefixItems_type(schema, raw_data) {
+        if (raw_data.length > schema.prefixItems.length) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, `Schema requires prefixItems of no more than ${schema.prefixItems.length}, ${raw_data.length} found!`);
+        }
+        const converted = [];
+        let index = 0;
+        for (const entry of schema.prefixItems) {
+            const converter = await Converter.find_matching_schema(await this.discovery.candidates, entry);
+            converted.push(await converter.convert(entry, raw_data[index]));
+            ++index;
+        }
+        return converted;
     }
 }

package/lib/DataDiscovery/JsonSchema/Object.js

@@ -61,7 +61,7 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         return converters;
     }
     async resolve_converters_for_$ref($ref) {
-        const definition = await this.discovery.docs.definition($ref.substring(8));
+        const definition = await this.discovery.docs.definition(this.discovery.version, $ref.substring(8));
         return this.resolve_converters(definition);
     }
     async resolve_schema(schema, depth = 0) {
@@ -85,7 +85,7 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         if ('$ref' in schema
             && is_string(schema.$ref)
             && schema.$ref.startsWith('#/$defs/')) {
-            for (const entry of Object.entries(await this.resolve_schema(await this.discovery.docs.definition(schema.$ref.substring(8)), depth + 1))) {
+            for (const entry of Object.entries(await this.resolve_schema(await this.discovery.docs.definition(this.discovery.version, schema.$ref.substring(8)), depth + 1))) {
                 const [property, sub_schema] = entry;
                 if (!(property in resolved_schema)) {
                     resolved_schema[property] = sub_schema;
@@ -128,10 +128,14 @@ export class ObjectConverter extends ObjectConverterMatchesSchema {
             performance.mark(`${this.constructor.name}.convert() property start`);
             if (!await converters[property].can_convert_schema_and_raw_data(sub_schema[property], value)) {
                 throw new NoMatchError({
+                    raw_data,
                     property,
+                    converter: converters[property].constructor.name,
+                    can_convert_schema: converters[property].can_convert_schema(sub_schema[property]),
                     value,
                     sub_schema: sub_schema[property],
                     instance: converters[property].constructor.name,
+                    schema,
                 }, 'Cannot convert value!');
             }
             performance.measure(`${this.constructor.name}.convert() property checked`, `${this.constructor.name}.convert() property start`);

package/lib/DataDiscovery/JsonSchema/OneOf.js

@@ -30,17 +30,37 @@ export class OneOfConverter extends ConverterMatchesSchema {
     }
     async convert(schema, raw_data) {
         const candidates = await this.discovery.candidates;
+        const failures = [];
         for (const entry of schema.oneOf) {
             const converter = await Converter.has_matching_schema_and_raw_data(candidates, entry, raw_data);
             if (converter
                 && await converter.can_convert_schema_and_raw_data(entry, raw_data)) {
-                return await converter.convert(entry, raw_data);
+                try {
+                    return await converter.convert(entry, raw_data);
+                }
+                catch (err) {
+                    if (err instanceof NoMatchError) {
+                        failures.push(err);
+                    }
+                }
             }
         }
         throw new NoMatchError({
             schema,
             raw_data,
-            oneOf: await Promise.all(schema.oneOf.map((e) => Converter.has_matching_schema_and_raw_data(candidates, e, raw_data))),
+            failures,
+            oneOf: await Promise.all(schema.oneOf.map(async (e) => {
+                // eslint-disable-next-line max-len
+                const converter = await Converter.has_matching_schema_and_raw_data(candidates, e, raw_data);
+                return [
+                    e,
+                    converter,
+                    (converter
+                        // eslint-disable-next-line max-len
+                        ? await converter.can_convert_schema_and_raw_data(e, raw_data)
+                        : 'no converter'),
+                ];
+            })),
         }, 'Unable to convert data!');
     }
 }

package/lib/DataDiscovery/JsonSchema/Ref.js

@@ -45,7 +45,7 @@ export class Ref extends ConverterMatchesSchema {
         performance.mark(`${this.constructor.name}.resolve_to_final_converter_schema_only() start`);
         if (!(schema.$ref in this.cache)) {
             while (this.can_convert_schema(checking)) {
-                checking = await this.discovery.docs.definition(checking.$ref.substring(8));
+                checking = await this.discovery.docs.definition(this.discovery.version, checking.$ref.substring(8));
             }
             if (this.can_convert_schema(checking)) {
                 throw new NoMatchError({

package/lib/DataDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
 import { GeneratesMarkdown } from './MarkdownUtilities';
 import { Converter } from './DataDiscovery/Generator';
 import { FilesGenerator } from './FilesGenerator';
@@ -16,7 +16,8 @@ export declare class DataDiscovery extends FilesGenerator implements GeneratesMa
     ]>;
     readonly docs: DocsTsGenerator;
     readonly literal: Literal;
-    constructor(docs: DocsTsGenerator, literal?: Literal);
+    readonly version: keyof docs_versions;
+    constructor(docs: DocsTsGenerator, version: keyof docs_versions, literal?: Literal);
     expecting(): Promise<progress>;
     generate(): Promise<[ts.Expression, DocsDataItem][]>;
     generate_files(): AsyncGenerator<{

package/lib/DataDiscovery.js

@@ -20,11 +20,13 @@ export class DataDiscovery extends FilesGenerator {
     candidates;
     docs;
     literal;
-    constructor(docs, literal) {
+    version;
+    constructor(docs, version, literal) {
         super();
         this.docs = docs;
         this.literal = literal || new Literal();
-        this.candidates = docs.schema().then(({ $defs }) => {
+        this.version = version;
+        this.candidates = docs.schema(version).then(({ $defs }) => {
             return [
                 new BooleanConverter(docs.ajv),
                 new ArrayConverter(this),
@@ -43,14 +45,14 @@ export class DataDiscovery extends FilesGenerator {
         });
     }
     async expecting() {
-        const json = await this.docs.get();
+        const json = await this.docs.get(this.version);
         return Object.fromEntries(json.map(e => [e.NativeClass, e.Classes.map(e => e.ClassName)]));
     }
     async generate() {
         const result = [];
         const [schema, docs,] = await Promise.all([
-            this.docs.schema(),
-            this.docs.get(),
+            this.docs.schema(this.version),
+            this.docs.get(this.version),
         ]);
         let index = 0;
         for (const e of docs) {