@satisfactory-dev/docs.json.ts 0.6.1

package/lib/TsFactoryWrapper.js

@@ -0,0 +1,236 @@
+import ts from 'typescript';
+import { is_string, } from './StringStartsWith';
+import { non_empty_map, } from './ArrayUtilities';
+export function adjust_class_name(class_name) {
+    if ('boolean' === class_name) {
+        return 'Docs_boolean';
+    }
+    if ('class' === class_name) {
+        return 'Docs_class';
+    }
+    return class_name.replace(/[^A-Za-z_\d]/g, '_');
+}
+export const modifier_map = {
+    abstract: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.AbstractKeyword);
+    },
+    public: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.PublicKeyword);
+    },
+    export: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
+    },
+    protected: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.ProtectedKeyword);
+    },
+    const: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.ConstKeyword);
+    },
+    readonly: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.ReadonlyKeyword);
+    },
+    static: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.StaticKeyword);
+    },
+    declare: () => {
+        return ts.factory.createModifier(ts.SyntaxKind.DeclareKeyword);
+    },
+};
+export function create_modifiers(first, ...rest) {
+    const modifiers = rest.reduce((was, is) => {
+        if (!was.includes(is)) {
+            was.push(is);
+        }
+        return was;
+    }, [first]);
+    return non_empty_map(modifiers, e => modifier_map[e]());
+}
+export function type_reference_node(name, ...type_arguments) {
+    return ts.factory.createTypeReferenceNode(name, type_arguments);
+}
+export function createClass(name, members, options = {}, type_parameters = undefined) {
+    let resolved_modifiers = undefined;
+    const resolved_heritage = [];
+    const { modifiers, extends: class_extends } = options;
+    if (modifiers && modifiers.length) {
+        resolved_modifiers = modifiers
+            .reduce((was, is) => {
+            if (!was.includes(is)) {
+                was.push(is);
+            }
+            return was;
+        }, [])
+            .map((modifier) => {
+            if ('export' === modifier) {
+                return ts.factory.createModifier(ts.SyntaxKind.ExportKeyword);
+            }
+            return ts.factory.createModifier(ts.SyntaxKind.AbstractKeyword);
+        });
+    }
+    if (class_extends) {
+        resolved_heritage.push(ts.factory.createHeritageClause(ts.SyntaxKind.ExtendsKeyword, [
+            ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(adjust_class_name(class_extends)), undefined),
+        ]));
+    }
+    return ts.factory.createClassDeclaration(resolved_modifiers, ts.factory.createIdentifier(adjust_class_name(name)), type_parameters, resolved_heritage, members);
+}
+export function createParameter(name, type, initializer = undefined) {
+    return ts.factory.createParameterDeclaration(undefined, undefined, name, undefined, 'object' === typeof type
+        ? type
+        : ts.factory.createKeywordTypeNode(type), initializer);
+}
+function create_method(name, type_parameters, parameters, modifiers, body, return_type = undefined) {
+    return ts.factory.createMethodDeclaration(create_modifiers(...modifiers), undefined, name, undefined, type_parameters.length ? type_parameters : undefined, parameters.map((entry) => {
+        if (!(entry instanceof Array)) {
+            return entry;
+        }
+        const [name, type] = entry;
+        return createParameter(name, type);
+    }), return_type, ts.factory.createBlock(body));
+}
+export function create_method_with_type_parameters(name, type_parameters, parameters, body, modifiers, return_type = undefined) {
+    return create_method(name, type_parameters, parameters, modifiers, body, return_type);
+}
+export function create_method_without_type_parameters(name, modifiers, parameters, body, return_type = undefined) {
+    return create_method(name, [], parameters, modifiers, body, return_type);
+}
+export function create_throw(throw_this, throw_arguments, type_parameters = undefined) {
+    return ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier(throw_this), type_parameters, throw_arguments));
+}
+export function create_throw_if(throw_this, throw_if, throw_arguments, type_parameters = undefined) {
+    return ts.factory.createIfStatement(throw_if, create_throw(throw_this, throw_arguments, type_parameters));
+}
+export function template_expression_from_string(template) {
+    const ast = ts.createSourceFile('create_span_from_template.ts', template, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    if (1 !== ast.statements.length) {
+        throw new Error('Input must have only one statement!');
+    }
+    else if (!ts.isExpressionStatement(ast.statements[0])) {
+        throw new Error('Input must be an expression statement!');
+    }
+    else if (!ts.isTemplateExpression(ast.statements[0].expression)) {
+        throw new Error('Input must be a template literal expression!');
+    }
+    return ast.statements[0].expression;
+}
+export function parenthesize(expression) {
+    return ts.factory.createParenthesizedExpression(expression);
+}
+export function create_property_access(on, property) {
+    return ts.factory.createPropertyAccessExpression(ts.isNewExpression(on) ? parenthesize(on) : on, property);
+}
+const type_map = {
+    boolean: ts.SyntaxKind.BooleanKeyword,
+    number: ts.SyntaxKind.NumberKeyword,
+    object: ts.SyntaxKind.ObjectKeyword,
+    string: ts.SyntaxKind.StringKeyword,
+    undefined: ts.SyntaxKind.UndefinedKeyword,
+    never: ts.SyntaxKind.NeverKeyword,
+    unknown: ts.SyntaxKind.UnknownKeyword,
+};
+export function create_type(type) {
+    return ts.factory.createKeywordTypeNode(type_map[type]);
+}
+export function create_object_type_from_entries(entries, required) {
+    return ts.factory.createTypeLiteralNode(entries.map((entry) => {
+        const [property, type] = entry;
+        return createPropertySignature(property, type, required ? required.includes(property) : true);
+    }));
+}
+export function createPropertySignature(property, type, required = true) {
+    return ts.factory.createPropertySignature(undefined, property_name_or_computed(property), required
+        ? undefined
+        : ts.factory.createToken(ts.SyntaxKind.QuestionToken), type);
+}
+export function needs_element_access(property) {
+    return /[?[\]]/.test(property);
+}
+export function computed_property_name_or_undefined(property) {
+    return needs_element_access(property)
+        ? ts.factory.createComputedPropertyName(ts.factory.createStringLiteral(property))
+        : undefined;
+}
+export function property_name_or_computed(property) {
+    return computed_property_name_or_undefined(property) || property;
+}
+export function minimum_size_array_of_single_type(repeat, generate, max = undefined) {
+    if (repeat < 0) {
+        throw new Error(`repeat must be greater than or equal to 0, ${repeat} given.`);
+    }
+    else if (repeat !== (repeat | 0)) {
+        throw new Error(`repeat must be an integer, ${repeat} given.`);
+    }
+    const types = [];
+    for (let iteration = 0; iteration < repeat; ++iteration) {
+        types.push(generate());
+    }
+    if (repeat === max) {
+        return ts.factory.createTupleTypeNode(types);
+    }
+    return ts.factory.createTupleTypeNode([
+        ...types,
+        ts.factory.createRestTypeNode(ts.factory.createArrayTypeNode(generate())),
+    ]);
+}
+export function create_this_assignment(property, identifier) {
+    return ts.factory.createExpressionStatement(ts.factory.createAssignment(needs_element_access(property)
+        ? ts.factory.createElementAccessExpression(ts.factory.createThis(), ts.factory.createStringLiteral(property))
+        : create_property_access(ts.factory.createThis(), property), is_string(identifier)
+        ? ts.factory.createIdentifier(identifier)
+        : identifier));
+}
+export function create_index_access(identifier, index) {
+    return ts.factory.createElementAccessExpression(ts.factory.createIdentifier(identifier), index);
+}
+export function create_literal(value) {
+    if (value instanceof RegExp) {
+        return ts.factory.createRegularExpressionLiteral(value.toString());
+    }
+    return ts.factory.createLiteralTypeNode(null === value
+        ? ts.factory.createNull()
+        : ts.factory.createStringLiteral(value));
+}
+export function create_union(a, b, ...rest) {
+    return ts.factory.createUnionTypeNode([a, b, ...rest]);
+}
+function map_lazy_union_item_to_type(item) {
+    if ('object' === typeof item) {
+        if ('$ref' in item) {
+            return type_reference_node(adjust_class_name(item.$ref.substring(8)));
+        }
+        if ('const' in item) {
+            return create_literal(item.const);
+        }
+        return type_reference_node('StringPassedRegExp', create_literal(item.pattern));
+    }
+    return create_literal(item);
+}
+export function create_lazy_union(a, b, ...rest) {
+    return create_union(map_lazy_union_item_to_type(a), map_lazy_union_item_to_type(b), ...rest.map(map_lazy_union_item_to_type));
+}
+export function possibly_create_lazy_union(items) {
+    if (items.length < 1) {
+        throw new Error('Cannot create lazy unions from empty arrays!');
+    }
+    else if (1 === items.length) {
+        return map_lazy_union_item_to_type(items[0]);
+    }
+    const [a, b, ...rest] = items;
+    return create_lazy_union(a, b, ...rest);
+}
+export function create_typed_union(items) {
+    return ts.factory.createUnionTypeNode(items.map(create_literal));
+}
+export function create_const_declaration_list(first, ...rest) {
+    return ts.factory.createVariableDeclarationList([first, ...rest], ts.NodeFlags.Const);
+}
+export function create_const_statement(first, ...rest) {
+    return ts.factory.createVariableStatement(undefined, create_const_declaration_list(first, ...rest));
+}
+export function variable(name, value, type = undefined) {
+    return ts.factory.createVariableDeclaration(name, undefined, type, value);
+}
+export function not(expression) {
+    return ts.factory.createLogicalNot(expression);
+}
+//# sourceMappingURL=TsFactoryWrapper.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.d.ts

@@ -0,0 +1,13 @@
+import { Generator } from '../Generator';
+import { UnrealEngineString_parent_type, UnrealEngineString_type } from '../../CustomParsingTypes/UnrealEngineString';
+import { TypeReferenceNode } from 'typescript';
+import Ajv from 'ajv/dist/2020';
+export type UnrealEngineString_left_right<left extends string = string, right extends string = string> = (Exclude<UnrealEngineString_type, true> & {
+    left: left;
+    right: right;
+});
+export declare class UnrealEngineString extends Generator<UnrealEngineString_parent_type, TypeReferenceNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: UnrealEngineString_parent_type) => TypeReferenceNode;
+    static fromString<left extends string = string, right extends string = string>(value: string): UnrealEngineString_left_right<left, right>;
+}

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -0,0 +1,26 @@
+import { Generator, } from '../Generator';
+import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
+export class UnrealEngineString extends Generator {
+    constructor(ajv) {
+        super(ajv, {
+            $defs: UnrealEngineString_schema_definitions,
+            ...UnrealEngineString_parent_schema,
+        });
+    }
+    generate() {
+        return (raw_data) => {
+            return UnrealEngineString_reference_type(raw_data.UnrealEngineString);
+        };
+    }
+    static fromString(value) {
+        const result = UnrealEngineString_regex.exec(value);
+        if (!result) {
+            throw new Error(`Not an UnrealEngineString (${value})`);
+        }
+        return {
+            left: result[1],
+            right: (result[2] || result[3]),
+        };
+    }
+}
+//# sourceMappingURL=UnrealEngineString.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.d.ts

@@ -0,0 +1,25 @@
+import { Generator } from '../Generator';
+import { TypeReferenceNode } from 'typescript';
+import Ajv from 'ajv/dist/2020';
+export type RawData = {
+    type: 'string';
+    string_starts_with: string;
+};
+export declare const schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        string_starts_with: {
+            type: string;
+        };
+    };
+};
+export declare class string_starts_with extends Generator<RawData, TypeReferenceNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: RawData) => TypeReferenceNode;
+}

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.js

@@ -0,0 +1,20 @@
+import { Generator, } from '../Generator';
+import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
+export const schema = {
+    type: 'object',
+    required: ['type', 'string_starts_with'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        string_starts_with: { type: 'string' },
+    },
+};
+export class string_starts_with extends Generator {
+    constructor(ajv) {
+        super(ajv, schema);
+    }
+    generate() {
+        return (raw_data) => type_reference_node('StringStartsWith', create_literal(raw_data.string_starts_with));
+    }
+}
+//# sourceMappingURL=string_starts_with.js.map

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.d.ts

@@ -0,0 +1,14 @@
+import { TupleTypeNode, TypeLiteralNode, UnionTypeNode } from 'typescript';
+import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
+import { typed_string_inner_array_prefixItems_type, typed_string_inner_array_type, typed_string_inner_object_pattern_type, typed_string_inner_object_type, typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
+import { local_ref } from '../../StringStartsWith';
+export declare class typed_string extends GeneratorDoesDiscovery<typed_string_parent_type, TypeLiteralNode | TupleTypeNode | UnionTypeNode> {
+    private readonly known_types;
+    constructor(supported_refs: local_ref<string>[], discovery: TypeDefinitionDiscovery);
+    generate(): (raw_data: typed_string_parent_type) => TypeLiteralNode | TupleTypeNode | UnionTypeNode;
+    static is_array_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_type;
+    static is_object_pattern_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_object_pattern_type;
+    static is_object_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_object_type;
+    static is_prefixItems_type(maybe: typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type): maybe is typed_string_inner_array_prefixItems_type;
+}

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js

@@ -0,0 +1,96 @@
+import ts from 'typescript';
+import { create_object_type_from_entries, createPropertySignature, minimum_size_array_of_single_type, } from '../../TsFactoryWrapper';
+import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { UnrealEngineString, } from './UnrealEngineString';
+import { generate_object_parent_schema, generate_typed_string_$defs, } from '../../CustomParsingTypes/TypedString';
+import { object_has_property, } from '../../CustomParsingTypes/CustomPairingTypes';
+function create_combinations(values) {
+    const as_array = [...values.values()];
+    const entered = [JSON.stringify(as_array)];
+    const result = [as_array];
+    const filter_these_out = [];
+    for (const item of as_array) {
+        const filtered = as_array.filter((maybe) => {
+            return (maybe !== item
+                && !filter_these_out.includes(maybe));
+        });
+        if (filtered.length) {
+            for (const entry of create_combinations(new Set(filtered))) {
+                const json_string = JSON.stringify(entry);
+                if (!entered.includes(json_string)) {
+                    entered.push(json_string);
+                    result.push(entry);
+                }
+            }
+        }
+    }
+    return [...(new Set(result)).values()];
+}
+export class typed_string extends GeneratorDoesDiscovery {
+    known_types;
+    constructor(supported_refs, discovery) {
+        super({
+            ...generate_object_parent_schema(),
+            $defs: {
+                ...generate_typed_string_$defs(supported_refs),
+            },
+        }, discovery);
+        this.known_types = [
+            new UnrealEngineString(discovery.docs.ajv),
+        ];
+    }
+    generate() {
+        return (raw_data) => {
+            const { typed_string: typed_string_value } = raw_data;
+            if (typed_string.is_array_type(typed_string_value)) {
+                for (const known_type of this.known_types) {
+                    if (known_type.check(typed_string_value.items)) {
+                        return minimum_size_array_of_single_type(typed_string_value.minItems, () => known_type.generate()(typed_string_value.items), typed_string_value.maxItems);
+                    }
+                }
+                return minimum_size_array_of_single_type(typed_string_value.minItems, () => this.discovery.find(typed_string_value.items), typed_string_value.maxItems);
+            }
+            else if (typed_string.is_prefixItems_type(typed_string_value)) {
+                return minimum_size_array_of_single_type(typed_string_value.minItems, () => ts.factory.createTupleTypeNode(typed_string_value.prefixItems.map(e => this.discovery.find(e))), typed_string_value.maxItems);
+            }
+            else if (typed_string.is_object_pattern_type(typed_string_value)) {
+                const [property_regex, value,] = Object.entries(typed_string_value.patternProperties)[0];
+                const properties = property_regex.substring(2, property_regex.length - 2).split('|');
+                const combinations = create_combinations(new Set(properties));
+                const value_generator = () => this.discovery.find(value);
+                const result = combinations.map((required) => {
+                    return ts.factory.createTypeLiteralNode(required.map(property => createPropertySignature(property, value_generator())));
+                });
+                return ts.factory.createUnionTypeNode(result);
+            }
+            return create_object_type_from_entries(Object.entries(typed_string_value.properties).map((entry) => {
+                for (const known_type of this.known_types) {
+                    if (known_type.check(entry[1])) {
+                        return [
+                            entry[0],
+                            known_type.generate()(entry[1]),
+                        ];
+                    }
+                }
+                return [
+                    entry[0],
+                    this.discovery.find(entry[1]),
+                ];
+            }), typed_string_value.required);
+        };
+    }
+    static is_array_type(maybe) {
+        return (object_has_property(maybe, 'items')
+            && !object_has_property(maybe, 'prefixItems'));
+    }
+    static is_object_pattern_type(maybe) {
+        return object_has_property(maybe, 'minProperties');
+    }
+    static is_object_type(maybe) {
+        return object_has_property(maybe, 'properties');
+    }
+    static is_prefixItems_type(maybe) {
+        return object_has_property(maybe, 'prefixItems');
+    }
+}
+//# sourceMappingURL=typed_string.js.map

package/lib/TypeDefinitionDiscovery/Generator.d.ts

@@ -0,0 +1,8 @@
+import Ajv, { SchemaObject, ValidateFunction } from 'ajv/dist/2020';
+import { TypeNode } from 'typescript';
+export type AnyGenerator = Generator<any>;
+export declare abstract class Generator<RawData, Type extends TypeNode = TypeNode> {
+    readonly check: ValidateFunction<RawData>;
+    protected constructor(ajv: Ajv, schema: SchemaObject);
+    abstract generate(): (raw_data: RawData) => Type;
+}

package/lib/TypeDefinitionDiscovery/Generator.js

@@ -0,0 +1,8 @@
+import { compile, } from '../AjvUtilities';
+export class Generator {
+    check;
+    constructor(ajv, schema) {
+        this.check = compile(ajv, schema);
+    }
+}
+//# sourceMappingURL=Generator.js.map

package/lib/TypeDefinitionDiscovery/GeneratorDoesDiscovery.d.ts

@@ -0,0 +1,8 @@
+import { TypeNode } from 'typescript';
+import { Generator } from './Generator';
+import { TypeDefinitionDiscovery } from '../TypeDefinitionDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+export declare abstract class GeneratorDoesDiscovery<RawData, Type extends TypeNode = TypeNode> extends Generator<RawData, Type> {
+    protected readonly discovery: TypeDefinitionDiscovery;
+    protected constructor(schema: SchemaObject, discovery: TypeDefinitionDiscovery);
+}

package/lib/TypeDefinitionDiscovery/GeneratorDoesDiscovery.js

@@ -0,0 +1,9 @@
+import { Generator, } from './Generator';
+export class GeneratorDoesDiscovery extends Generator {
+    discovery;
+    constructor(schema, discovery) {
+        super(discovery.docs.ajv, schema);
+        this.discovery = discovery;
+    }
+}
+//# sourceMappingURL=GeneratorDoesDiscovery.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/ArrayType.d.ts

@@ -0,0 +1,19 @@
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
+import ts, { ArrayTypeNode, TupleTypeNode } from 'typescript';
+import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+type RawData = {
+    type: 'array';
+    minItems?: 1;
+    maxItems?: 1;
+    items: {
+        [key: string]: unknown;
+    } | false;
+    prefixItems?: {
+        $ref: string;
+    }[];
+};
+export declare class ArrayType extends GeneratorDoesDiscovery<RawData, TupleTypeNode | ArrayTypeNode> {
+    constructor(supported_refs: string[], discovery: TypeDefinitionDiscovery);
+    generate(): (raw_data: RawData) => ts.ArrayTypeNode | ts.TupleTypeNode;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/ArrayType.js

@@ -0,0 +1,61 @@
+import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import ts from 'typescript';
+import { object_has_non_empty_array_property, object_has_property, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { minimum_size_array_of_single_type, } from '../../TsFactoryWrapper';
+import { NoMatchError, } from '../../Exceptions';
+export class ArrayType extends GeneratorDoesDiscovery {
+    constructor(supported_refs, discovery) {
+        super({
+            type: 'object',
+            required: ['type', 'items'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'array' },
+                minItems: { type: 'number', minimum: 0 },
+                maxItems: { type: 'number', minimum: 1 },
+                items: {
+                    oneOf: [
+                        { type: 'object' },
+                        { type: 'boolean', const: false },
+                    ],
+                },
+                uniqueItems: { type: 'boolean', const: true },
+                prefixItems: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'object',
+                        required: ['$ref'],
+                        additionalProperties: false,
+                        properties: {
+                            type: { type: 'string', const: 'object' },
+                            $ref: {
+                                type: 'string',
+                                enum: supported_refs,
+                            },
+                            unevaluatedProperties: {
+                                type: 'boolean',
+                                const: false,
+                            },
+                        },
+                    },
+                },
+            },
+        }, discovery);
+    }
+    generate() {
+        return (raw_data) => {
+            if (false === raw_data.items) {
+                if (!object_has_non_empty_array_property(raw_data, 'prefixItems')) {
+                    throw new NoMatchError(raw_data, 'Must specify prefixItems when items is false!');
+                }
+                return ts.factory.createTupleTypeNode(raw_data.prefixItems.map(e => this.discovery.find(e)));
+            }
+            if (object_has_property(raw_data, 'minItems')) {
+                return minimum_size_array_of_single_type(raw_data.minItems, () => this.discovery.find(raw_data.items), raw_data.maxItems);
+            }
+            return ts.factory.createArrayTypeNode(this.discovery.find(raw_data.items));
+        };
+    }
+}
+//# sourceMappingURL=ArrayType.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject.d.ts

@@ -0,0 +1,23 @@
+import { IntersectionTypeNode, LiteralTypeNode, TypeReferenceNode } from 'typescript';
+import { RawData as ObjectTypeRawData } from '../ObjectType';
+import { TypeDefinitionDiscovery } from '../../../TypeDefinitionDiscovery';
+import { GeneratorDoesDiscovery } from '../../GeneratorDoesDiscovery';
+import { local_ref } from '../../../StringStartsWith';
+type RawData = ObjectTypeRawData & {
+    properties: {
+        [key: string]: unknown;
+    };
+    $ref: local_ref<string>;
+};
+type Type = TypeReferenceNode | (IntersectionTypeNode & {
+    types: [
+        TypeReferenceNode,
+        LiteralTypeNode
+    ];
+});
+export declare class ExtendsObject extends GeneratorDoesDiscovery<RawData, Type> {
+    constructor(supported_refs: string[], discovery: TypeDefinitionDiscovery);
+    generate(): (raw_data: RawData) => Type;
+    protected create_reference_type($ref: local_ref<string>): TypeReferenceNode;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject.js

@@ -0,0 +1,40 @@
+import ts from 'typescript';
+import { schema as ObjectTypeSchema, } from '../ObjectType';
+import { adjust_class_name, } from '../../../TsFactoryWrapper';
+import { GeneratorDoesDiscovery, } from '../../GeneratorDoesDiscovery';
+export class ExtendsObject extends GeneratorDoesDiscovery {
+    constructor(supported_refs, discovery) {
+        const { type, additionalProperties, properties, ...rest } = ObjectTypeSchema;
+        super({
+            ...rest,
+            type,
+            additionalProperties,
+            required: ['$ref'],
+            properties: {
+                ...properties,
+                $ref: { type: 'string', enum: supported_refs },
+                unevaluatedProperties: { type: 'boolean', const: false },
+            },
+        }, discovery);
+    }
+    generate() {
+        return (raw_data) => {
+            const { $ref, properties, ...rest } = raw_data;
+            const reference_type = this.create_reference_type($ref);
+            if (undefined === properties) {
+                return reference_type;
+            }
+            return ts.factory.createIntersectionTypeNode([
+                reference_type,
+                this.discovery.find({
+                    ...rest,
+                    properties,
+                }),
+            ]);
+        };
+    }
+    create_reference_type($ref) {
+        return ts.factory.createTypeReferenceNode(adjust_class_name(`${$ref.substring(8)}__type`));
+    }
+}
+//# sourceMappingURL=ExtendsObject.js.map