@satisfactory-dev/docs.json.ts 0.6.1

package/lib/DataDiscovery/CustomTypes/TypedString.js

@@ -0,0 +1,251 @@
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { generate_object_parent_schema, generate_typed_string_$defs, } from '../../CustomParsingTypes/TypedString';
+import { is_string, local_ref, } from '../../StringStartsWith';
+import { NoMatchError, } from '../../Exceptions';
+import { string_to_array, string_to_object, } from '../../DocsValidation';
+import { compile, } from '../../AjvUtilities';
+import { typed_string, } from '../../TypeDefinitionDiscovery/CustomParsingTypes/typed_string';
+import assert from 'node:assert/strict';
+export class TypedStringConverter extends ConverterMatchesSchema {
+    $defs;
+    discovery;
+    regex_schema_cache = {};
+    constructor(discovery, $defs) {
+        const local_refs = Object.keys($defs).map(local_ref);
+        super(discovery.docs.ajv, {
+            ...generate_object_parent_schema(),
+            $defs: {
+                ...$defs,
+                ...generate_typed_string_$defs(local_refs),
+            },
+        });
+        this.discovery = discovery;
+        this.$defs = $defs;
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(this.can_convert_schema(schema)
+            && is_string(raw_data)
+            && (('required' in schema.typed_string
+                && false !== string_to_object(raw_data, true))
+                || ('patternProperties' in schema.typed_string
+                    && false !== string_to_object(raw_data, true))
+                || (!('required' in schema.typed_string)
+                    && ((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)))))));
+    }
+    async convert(schema, raw_data) {
+        if (!await this.can_convert_schema_and_raw_data(schema, raw_data)) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, 'Cannot convert!');
+        }
+        else if (typed_string.is_object_type(schema.typed_string)
+            || typed_string.is_object_pattern_type(schema.typed_string)) {
+            const shallow = string_to_object(raw_data, true);
+            assert.notEqual(shallow, false, new NoMatchError({
+                raw_data,
+            }, 'raw data not a typed_string!'));
+            return this.convert_object(schema.typed_string, shallow);
+        }
+        const shallow = string_to_array(raw_data, true);
+        assert.notEqual(shallow, false, new NoMatchError({
+            raw_data,
+        }, 'raw data not a typed string!'));
+        if (typed_string.is_array_type(schema.typed_string)) {
+            return this.convert_array(schema.typed_string, shallow);
+        }
+        else if (typed_string.is_prefixItems_type(schema.typed_string)) {
+            return this.convert_prefixItems(schema.typed_string, shallow);
+        }
+        throw new NoMatchError({
+            raw_data,
+            shallow,
+            schema,
+        }, 'Failed to convert native type!');
+    }
+    check_shallow_array_prefixItems_schema(schema, shallow) {
+        if (!(shallow instanceof Array)) {
+            return false;
+        }
+        for (const entry of shallow) {
+            if (!is_string(entry)) {
+                return false;
+            }
+            const inner_shallow = string_to_array(entry, true);
+            if (false === inner_shallow
+                || !this.check_shallow_array_schema(schema, inner_shallow)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    check_shallow_array_schema(schema, shallow) {
+        if (false === shallow) {
+            return false;
+        }
+        const check = compile(this.discovery.docs.ajv, {
+            ...schema,
+            $defs: this.$defs,
+            type: 'array',
+        });
+        return !!check(shallow);
+    }
+    check_shallow_array_schema_assert(schema, shallow) {
+        const check = compile(this.discovery.docs.ajv, {
+            ...schema,
+            $defs: this.$defs,
+            type: 'array',
+        });
+        if (!check(shallow)) {
+            throw new NoMatchError({
+                shallow,
+                schema,
+                errors: check.errors,
+            }, 'Shallow parse of typed_string does not match array schema!');
+        }
+    }
+    async convert_array(schema, shallow) {
+        performance.mark(`${this.constructor.name}.convert_array() start`);
+        this.check_shallow_array_schema_assert(schema, shallow);
+        const converter = await Converter.find_matching_schema(await this.discovery.candidates, schema.items);
+        const items = [];
+        for (const e of shallow) {
+            items.push(await converter.convert(schema.items, e));
+        }
+        const result = new ExpressionResult(await this.discovery.literal.array_literal(items));
+        performance.measure(`${this.constructor.name}.convert_array()`, `${this.constructor.name}.convert_array() start`);
+        return result;
+    }
+    async convert_object(schema, shallow) {
+        performance.mark(`${this.constructor.name}.convert_object() start`);
+        this.convert_object_check_shallow_parse(schema, shallow);
+        const converted_entries = [];
+        for (const entry of Object.entries(shallow)) {
+            const [property, value] = entry;
+            const property_schema = this.convert_object_property_schema(schema, property);
+            const converter = await Converter.find_matching_schema(await this.discovery.candidates, property_schema);
+            converted_entries.push([
+                property,
+                await converter.convert(property_schema, value),
+            ]);
+        }
+        const converted = Object.fromEntries(converted_entries);
+        performance.measure(`${this.constructor.name}.convert_object() bootstrap`, `${this.constructor.name}.convert_object() start`);
+        try {
+            performance.mark(`${this.constructor.name}.convert_object() start`);
+            const result = new ExpressionResult(await this.discovery.literal.object_literal(converted));
+            performance.measure(`${this.constructor.name}.convert_object()`, `${this.constructor.name}.convert_object() start`);
+            return result;
+        }
+        catch (error) {
+            throw new NoMatchError({
+                converted,
+                error,
+            }, 'Failed to grab object literal!');
+        }
+    }
+    convert_object_check_shallow_parse(schema, shallow) {
+        performance.mark(`${this.constructor.name}.convert_object_check_shallow_parse() start`);
+        const check = compile(this.discovery.docs.ajv, {
+            ...schema,
+            $defs: this.$defs,
+            type: 'object',
+        });
+        const result = check(shallow);
+        performance.measure(`${this.constructor.name}.convert_object_check_shallow_parse()`, `${this.constructor.name}.convert_object_check_shallow_parse() start`);
+        if (!result) {
+            throw new NoMatchError({
+                shallow,
+                schema,
+                errors: check.errors,
+            }, 'Shallow parse of typed_string does not match object schema!');
+        }
+    }
+    convert_object_property_schema(schema, property) {
+        performance.mark(`${this.constructor.name}.convert_object_property_schema() start`);
+        if ('properties' in schema) {
+            if (!(property in schema.properties)) {
+                performance.measure(`${this.constructor.name}.convert_object_property_schema() object failure`, `${this.constructor.name}.convert_object_property_schema() start`);
+                throw new NoMatchError({
+                    property,
+                    schema,
+                }, 'Property not in schema!');
+            }
+            performance.measure(`${this.constructor.name}.convert_object_property_schema() object schema`, `${this.constructor.name}.convert_object_property_schema() start`);
+            return schema.properties[property];
+        }
+        const json_string = JSON.stringify(schema.patternProperties);
+        if (!(json_string in this.regex_schema_cache)) {
+            this.regex_schema_cache[json_string] = Object.entries(schema.patternProperties).map((e) => {
+                return [
+                    new RegExp(e[0]),
+                    e[1],
+                ];
+            });
+            performance.measure(`${this.constructor.name}.convert_object_property_schema() pattern caching`, `${this.constructor.name}.convert_object_property_schema() start`);
+        }
+        const property_regex_schema = this.regex_schema_cache[json_string].find(maybe => maybe[0].test(property));
+        if (!property_regex_schema) {
+            performance.measure(`${this.constructor.name}.convert_object_property_schema() pattern failure`, `${this.constructor.name}.convert_object_property_schema() start`);
+            throw new NoMatchError({
+                property,
+                schema,
+            }, 'Property not in schema!');
+        }
+        performance.measure(`${this.constructor.name}.convert_object_property_schema() pattern schema`, `${this.constructor.name}.convert_object_property_schema() start`);
+        return property_regex_schema[1];
+    }
+    async convert_prefixItems(schema, shallow) {
+        performance.mark(`${this.constructor.name}.convert_prefixItems() start`);
+        const slightly_less_than_shallow = [];
+        for (const entry of shallow) {
+            if (!is_string(entry)) {
+                throw new NoMatchError({
+                    schema,
+                    shallow,
+                    entry,
+                }, 'Expecting string entries on shallow array!');
+            }
+            const inner_shallow = string_to_array(entry, true);
+            if (false === inner_shallow) {
+                throw new NoMatchError({
+                    entry,
+                }, 'Failed to parse inner entry!');
+            }
+            this.check_shallow_array_schema_assert(schema, inner_shallow);
+            slightly_less_than_shallow.push(inner_shallow);
+        }
+        const converted = [];
+        for (const e of slightly_less_than_shallow) {
+            if (e.length !== schema.prefixItems.length) {
+                throw new NoMatchError({
+                    e,
+                    schema,
+                }, `Expected an array of length ${schema.prefixItems.length}, received ${e.length}`);
+            }
+            const items = [];
+            let index = 0;
+            for (const entry of e) {
+                const type = schema.prefixItems[index];
+                const converter = await Converter.find_matching_schema(await this.discovery.candidates, type);
+                if (!await converter.can_convert_schema_and_raw_data(type, entry)) {
+                    throw new NoMatchError({
+                        entry,
+                        type,
+                        converter: converter.constructor.name,
+                    }, 'Cannot convert entry!');
+                }
+                items.push(await converter.convert(type, entry));
+                ++index;
+            }
+            converted.push(new ExpressionResult(await this.discovery.literal.array_literal(items)));
+        }
+        const result = new ExpressionResult(await this.discovery.literal.array_literal(converted));
+        performance.measure(`${this.constructor.name}.convert_prefixItems()`, `${this.constructor.name}.convert_prefixItems() start`);
+        return result;
+    }
+}
+//# sourceMappingURL=TypedString.js.map

package/lib/DataDiscovery/CustomTypes/UnrealEngineString.d.ts

@@ -0,0 +1,9 @@
+import { Converter, ExpressionResult } from '../Generator';
+import { UnrealEngineString_parent_type } from '../../CustomParsingTypes/UnrealEngineString';
+import { CallExpression } from 'typescript';
+import { SchemaObject } from 'ajv';
+export declare class UnrealEngineStringConverter extends Converter<UnrealEngineString_parent_type, string, CallExpression> {
+    can_convert_schema(schema: SchemaObject): schema is UnrealEngineString_parent_type;
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: UnrealEngineString_parent_type, raw_data: string): Promise<ExpressionResult<CallExpression>>;
+}

package/lib/DataDiscovery/CustomTypes/UnrealEngineString.js

@@ -0,0 +1,45 @@
+import { Converter, ExpressionResult, } from '../Generator';
+import { is_string, } from '../../StringStartsWith';
+import { is_UnrealEngineString_parent, string_or_string_array_to_node, UnrealEngineString_regex, } from '../../CustomParsingTypes/UnrealEngineString';
+import ts from 'typescript';
+import { create_literal, create_property_access, create_type, type_reference_node, } from '../../TsFactoryWrapper';
+import { object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { NoMatchError, } from '../../Exceptions';
+export class UnrealEngineStringConverter extends Converter {
+    can_convert_schema(schema) {
+        return is_UnrealEngineString_parent(schema);
+    }
+    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));
+    }
+    async convert(schema, raw_data) {
+        if (!await this.can_convert_schema_and_raw_data(schema, raw_data)) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, 'Not an UnrealEngineString!');
+        }
+        const type_args = [
+            create_literal('/Script/Engine.BlueprintGeneratedClass'),
+            create_type('string'),
+        ];
+        const { UnrealEngineString } = schema;
+        if (true !== UnrealEngineString) {
+            if (object_has_property(UnrealEngineString, 'left')) {
+                type_args[0] = string_or_string_array_to_node(UnrealEngineString.left);
+            }
+            if (object_has_property(UnrealEngineString, 'right')) {
+                if (value_is_non_array_object(UnrealEngineString.right)) {
+                    type_args[1] = type_reference_node('StringStartsWith', string_or_string_array_to_node(UnrealEngineString.right.starts_with));
+                }
+                else {
+                    type_args[1] = string_or_string_array_to_node(UnrealEngineString.right);
+                }
+            }
+        }
+        return new ExpressionResult(ts.factory.createCallExpression(create_property_access(ts.factory.createIdentifier('UnrealEngineString'), 'fromString'), type_args, [ts.factory.createStringLiteral(raw_data)]));
+    }
+}
+//# sourceMappingURL=UnrealEngineString.js.map

package/lib/DataDiscovery/Generator.d.ts

@@ -0,0 +1,19 @@
+import { Expression } from 'typescript';
+import Ajv, { SchemaObject, ValidateFunction } from 'ajv/dist/2020';
+export declare abstract class Converter<Schema extends SchemaObject, RawData = unknown, Output extends Expression = Expression> {
+    abstract can_convert_schema(schema: SchemaObject): schema is Schema;
+    abstract can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    abstract convert(schema: Schema, raw_data: RawData): Promise<ExpressionResult<Output>>;
+    static find_matching_schema(candidates: [Converter<SchemaObject>, ...Converter<SchemaObject>[]], schema: SchemaObject): Promise<Converter<SchemaObject>>;
+    static has_matching_schema(candidates: [Converter<SchemaObject>, ...Converter<SchemaObject>[]], schema: SchemaObject): Converter<SchemaObject> | undefined;
+    static has_matching_schema_and_raw_data(candidates: [Converter<SchemaObject>, ...Converter<SchemaObject>[]], schema: SchemaObject, raw_data: unknown): Promise<Converter<SchemaObject> | undefined>;
+}
+export declare abstract class ConverterMatchesSchema<Schema extends SchemaObject, RawData = unknown, Output extends Expression = Expression> extends Converter<Schema, RawData, Output> {
+    protected check_schema: ValidateFunction<Schema>;
+    protected constructor(ajv: Ajv, schema: SchemaObject);
+    can_convert_schema(schema: SchemaObject): schema is Schema;
+}
+export declare class ExpressionResult<T extends Expression = Expression> {
+    readonly expression: T;
+    constructor(expression: T);
+}

package/lib/DataDiscovery/Generator.js

@@ -0,0 +1,41 @@
+import { NoMatchError, } from '../Exceptions';
+import { compile, } from '../AjvUtilities';
+export class Converter {
+    static find_matching_schema(candidates, schema) {
+        const converter = this.has_matching_schema(candidates, schema);
+        if (converter) {
+            return Promise.resolve(converter);
+        }
+        return Promise.reject(new NoMatchError({
+            schema,
+        }, 'Could not identify suitable candidate!'));
+    }
+    static has_matching_schema(candidates, schema) {
+        return candidates.find(e => e.can_convert_schema(schema));
+    }
+    static async has_matching_schema_and_raw_data(candidates, schema, raw_data) {
+        for (const candidate of candidates) {
+            if (await candidate.can_convert_schema_and_raw_data(schema, raw_data)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+}
+export class ConverterMatchesSchema extends Converter {
+    check_schema;
+    constructor(ajv, schema) {
+        super();
+        this.check_schema = compile(ajv, schema);
+    }
+    can_convert_schema(schema) {
+        return !!this.check_schema(schema);
+    }
+}
+export class ExpressionResult {
+    expression;
+    constructor(expression) {
+        this.expression = expression;
+    }
+}
+//# sourceMappingURL=Generator.js.map

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

@@ -0,0 +1,17 @@
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { DataDiscovery } from '../../DataDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+import { ArrayLiteralExpression } from 'typescript';
+type array_type = {
+    type: 'array';
+    items: SchemaObject;
+    minItems: number;
+    maxItems?: number;
+};
+export declare class ArrayConverter extends ConverterMatchesSchema<array_type, unknown[], ArrayLiteralExpression> {
+    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>>;
+}
+export {};

package/lib/DataDiscovery/JsonSchema/Array.js

@@ -0,0 +1,41 @@
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { NoMatchError, } from '../../Exceptions';
+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 },
+            },
+        });
+        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));
+    }
+    async convert(schema, raw_data) {
+        if (!this.can_convert_schema(schema)
+            || !await this.can_convert_schema_and_raw_data(schema, raw_data)) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, 'Cannot convert!');
+        }
+        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));
+    }
+}
+//# sourceMappingURL=Array.js.map

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

@@ -0,0 +1,61 @@
+import { Converter, ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { DataDiscovery } from '../../DataDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+import { local_ref } from '../../StringStartsWith';
+import { Expression, ObjectLiteralExpression } from 'typescript';
+import { typed_string_inner_object_pattern_type } from '../../CustomParsingTypes/TypedString';
+export type schema_type = {
+    type: 'object';
+    $ref: local_ref<string>;
+    unevaluatedProperties?: false;
+    required?: [string, ...string[]];
+    properties?: {
+        [key: string]: SchemaObject;
+    };
+};
+declare abstract class ObjectConverterMatchesSchema<Schema extends SchemaObject, RawData = unknown, Output extends Expression = Expression> extends ConverterMatchesSchema<Schema, RawData, Output> {
+    protected readonly already_resolved: {
+        [key: string]: {
+            [key: string]: SchemaObject;
+        };
+    };
+    protected readonly discovery: DataDiscovery;
+    constructor(discovery: DataDiscovery, schema: SchemaObject);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    check_converters(schema: schema_type, raw_data: {
+        [key: string]: unknown;
+    }): Promise<{
+        [key: string]: Converter<SchemaObject, unknown, Expression>;
+    }>;
+    check_converters_for_missing_keys(raw_data: {
+        [key: string]: unknown;
+    }, converters: {
+        [key: string]: Converter<SchemaObject>;
+    }): string[];
+    protected resolve_converters(schema: SchemaObject): Promise<{
+        [key: string]: Converter<SchemaObject>;
+    }>;
+    protected resolve_converters_for_$ref($ref: local_ref<string>): Promise<{
+        [key: string]: Converter<SchemaObject>;
+    }>;
+    protected resolve_schema(schema: SchemaObject, depth?: number): Promise<{
+        [key: string]: SchemaObject;
+    }>;
+}
+export declare class ObjectConverter extends ObjectConverterMatchesSchema<schema_type, {
+    [key: string]: unknown;
+}, ObjectLiteralExpression> {
+    constructor(discovery: DataDiscovery);
+    convert(schema: schema_type, raw_data: {
+        [key: string]: unknown;
+    }): Promise<ExpressionResult<ObjectLiteralExpression>>;
+}
+export declare class PatternedObjectConverter extends ObjectConverterMatchesSchema<typed_string_inner_object_pattern_type, {
+    [key: string]: unknown;
+}, ObjectLiteralExpression> {
+    constructor(discovery: DataDiscovery);
+    convert(schema: typed_string_inner_object_pattern_type, raw_data: {
+        [key: string]: unknown;
+    }): Promise<ExpressionResult<ObjectLiteralExpression>>;
+}
+export {};

package/lib/DataDiscovery/JsonSchema/Object.js

@@ -0,0 +1,184 @@
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { is_string, } from '../../StringStartsWith';
+import { NoMatchError, } from '../../Exceptions';
+import { pattern_properties_regex, } from '../../CustomParsingTypes/TypedString';
+class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
+    already_resolved = {};
+    discovery;
+    constructor(discovery, schema) {
+        super(discovery.docs.ajv, schema);
+        this.discovery = discovery;
+    }
+    async can_convert_schema_and_raw_data(schema, raw_data) {
+        return (this.can_convert_schema(schema)
+            && value_is_non_array_object(raw_data)
+            && 0 === this.check_converters_for_missing_keys(raw_data, await this.resolve_converters(schema)).length
+            && await new Promise((yup => {
+                this.convert(schema, raw_data).then(() => yup(true)).catch(() => yup(false));
+            })));
+    }
+    async check_converters(schema, raw_data) {
+        const converters = await this.resolve_converters(schema);
+        performance.mark(`${this.constructor.name}.check_converters() start`);
+        const missing_keys = this.check_converters_for_missing_keys(raw_data, converters);
+        if (missing_keys.length) {
+            performance.measure(`${this.constructor.name}.check_converters() missing converters`, `${this.constructor.name}.check_converters() start`);
+            throw new NoMatchError({
+                missing_keys,
+                schema,
+                raw_data,
+            }, 'Missing converters');
+        }
+        return converters;
+    }
+    check_converters_for_missing_keys(raw_data, converters) {
+        return Object.keys(raw_data).filter((maybe) => !(maybe in converters));
+    }
+    async resolve_converters(schema) {
+        performance.mark(`${this.constructor.name}.resolve_converters() start`);
+        const converters = {};
+        if (object_has_property(schema, 'properties', (maybe) => {
+            return (value_is_non_array_object(maybe)
+                && Object.values(maybe).every(e => value_is_non_array_object(e)));
+        })) {
+            const { properties } = schema;
+            for (const entry of Object.entries(properties)) {
+                converters[entry[0]] = await Converter.find_matching_schema(await this.discovery.candidates, entry[1]);
+            }
+        }
+        if ('$ref' in schema
+            && is_string(schema.$ref)
+            && schema.$ref.startsWith('#/$defs/')) {
+            const $ref_converters = Object.entries(await this.resolve_converters_for_$ref(schema.$ref));
+            for (const entry of $ref_converters) {
+                const [property, converter] = entry;
+                if (!(property in converters)) {
+                    converters[property] = converter;
+                }
+            }
+        }
+        performance.measure(`${this.constructor.name}.resolve_converters() resolve_converters`, `${this.constructor.name}.resolve_converters() start`);
+        return converters;
+    }
+    async resolve_converters_for_$ref($ref) {
+        const definition = await this.discovery.docs.definition($ref.substring(8));
+        return this.resolve_converters(definition);
+    }
+    async resolve_schema(schema, depth = 0) {
+        performance.mark(`${this.constructor.name}.resolve_schema() start`);
+        const json_string = JSON.stringify(schema);
+        if (json_string in this.already_resolved) {
+            performance.measure(`${this.constructor.name}.resolve_schema() previously resolved`, `${this.constructor.name}.resolve_schema() start`);
+            return this.already_resolved[json_string];
+        }
+        const resolved_schema = {};
+        if (object_has_property(schema, 'properties', (e) => {
+            return (value_is_non_array_object(e)
+                && Object.values(e).every(value_is_non_array_object));
+        })) {
+            const { properties } = schema;
+            for (const entry of Object.entries(properties)) {
+                const [property, sub_schema] = entry;
+                resolved_schema[property] = sub_schema;
+            }
+        }
+        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))) {
+                const [property, sub_schema] = entry;
+                if (!(property in resolved_schema)) {
+                    resolved_schema[property] = sub_schema;
+                }
+            }
+        }
+        performance.measure(`${this.constructor.name}.resolve_schema()`, `${this.constructor.name}.resolve_schema() start`);
+        this.already_resolved[json_string] = resolved_schema;
+        return resolved_schema;
+    }
+}
+export class ObjectConverter extends ObjectConverterMatchesSchema {
+    constructor(discovery) {
+        super(discovery, {
+            type: 'object',
+            required: ['type'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'object' },
+                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+                required: {
+                    type: 'array',
+                    minItems: 1,
+                    items: { type: 'string' },
+                },
+                additionalProperties: { type: 'boolean', const: false },
+                unevaluatedProperties: { type: 'boolean', const: false },
+                properties: { type: 'object', minProperties: 1 },
+            },
+        });
+    }
+    async convert(schema, raw_data) {
+        performance.mark(`${this.constructor.name}.convert() start`);
+        const sub_schema = await this.resolve_schema(schema);
+        performance.measure(`${this.constructor.name}.convert() sub_schema`, `${this.constructor.name}.convert() start`);
+        const converters = await this.check_converters(schema, raw_data);
+        const result = {};
+        for (const entry of Object.entries(raw_data)) {
+            const [property, value] = entry;
+            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({
+                    property,
+                    value,
+                    sub_schema: sub_schema[property],
+                    instance: converters[property].constructor.name,
+                }, 'Cannot convert value!');
+            }
+            performance.measure(`${this.constructor.name}.convert() property checked`, `${this.constructor.name}.convert() property start`);
+            performance.mark(`${this.constructor.name}.convert() property start`);
+            result[property] = await converters[property].convert(sub_schema[property], value);
+            performance.measure(`${this.constructor.name}.convert() property converted`, `${this.constructor.name}.convert() property start`);
+        }
+        performance.measure(`${this.constructor.name}.convert() converted`, `${this.constructor.name}.convert() start`);
+        performance.mark(`${this.constructor.name}.convert() start`);
+        const expression = new ExpressionResult(await this.discovery.literal.object_literal(result));
+        performance.measure(`${this.constructor.name}.convert() expression`, `${this.constructor.name}.convert() start`);
+        return expression;
+    }
+}
+export class PatternedObjectConverter extends ObjectConverterMatchesSchema {
+    constructor(discovery) {
+        super(discovery, {
+            type: 'object',
+            required: ['type', 'minProperties', 'patternProperties'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'object' },
+                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+                additionalProperties: { type: 'boolean', const: false },
+                unevaluatedProperties: { type: 'boolean', const: false },
+                minProperties: { type: 'number', minimum: 1 },
+                maxProperties: { type: 'number', minimum: 1 },
+                patternProperties: {
+                    type: 'object',
+                    minProperties: 1,
+                    maxProperties: 1,
+                    patternProperties: {
+                        [pattern_properties_regex]: {
+                            type: 'object',
+                            minProperties: 1,
+                        },
+                    },
+                },
+            },
+        });
+    }
+    convert(schema, raw_data) {
+        throw new NoMatchError({
+            schema,
+            raw_data,
+        }, 'Method not implemented.');
+    }
+}
+//# sourceMappingURL=Object.js.map