@satisfactory-dev/docs.json.ts 0.6.1

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

@@ -0,0 +1,13 @@
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { DataDiscovery } from '../../DataDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+type oneOf = {
+    oneOf: [SchemaObject, ...SchemaObject[]];
+};
+export declare class OneOfConverter extends ConverterMatchesSchema<oneOf> {
+    private readonly discovery;
+    constructor(discovery: DataDiscovery);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: oneOf, raw_data: unknown): Promise<ExpressionResult>;
+}
+export {};

package/lib/DataDiscovery/JsonSchema/OneOf.js

@@ -0,0 +1,47 @@
+import { Converter, ConverterMatchesSchema, } from '../Generator';
+import { NoMatchError, } from '../../Exceptions';
+const schema = {
+    type: 'object',
+    required: ['oneOf'],
+    additionalProperties: false,
+    properties: {
+        oneOf: {
+            type: 'array',
+            minItems: 1,
+            items: { type: 'object', minProperties: 1 },
+        },
+    },
+};
+export class OneOfConverter extends ConverterMatchesSchema {
+    discovery;
+    constructor(discovery) {
+        super(discovery.docs.ajv, schema);
+        this.discovery = discovery;
+    }
+    async can_convert_schema_and_raw_data(schema, raw_data) {
+        if (this.can_convert_schema(schema)) {
+            for (const entry of schema.oneOf) {
+                if (await Converter.has_matching_schema_and_raw_data(await this.discovery.candidates, entry, raw_data)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async convert(schema, raw_data) {
+        const candidates = await this.discovery.candidates;
+        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);
+            }
+        }
+        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))),
+        }, 'Unable to convert data!');
+    }
+}
+//# sourceMappingURL=OneOf.js.map

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

@@ -0,0 +1,17 @@
+import { Converter, ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import { local_ref } from '../../StringStartsWith';
+import { DataDiscovery } from '../../DataDiscovery';
+import { SchemaObject } from 'ajv/dist/2020';
+type schema_type = {
+    $ref: local_ref<string>;
+};
+type final_resolve_result = [SchemaObject, Converter<SchemaObject>];
+export declare class Ref extends ConverterMatchesSchema<schema_type> {
+    private readonly cache;
+    private readonly discovery;
+    constructor(discovery: DataDiscovery);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: schema_type, raw_data: schema_type): Promise<ExpressionResult>;
+    resolve_to_final_converter_schema_only(schema: schema_type): Promise<final_resolve_result>;
+}
+export {};

package/lib/DataDiscovery/JsonSchema/Ref.js

@@ -0,0 +1,66 @@
+import { Converter, ConverterMatchesSchema, } from '../Generator';
+import { NoMatchError, } from '../../Exceptions';
+export class Ref extends ConverterMatchesSchema {
+    cache = {};
+    discovery;
+    constructor(discovery) {
+        super(discovery.docs.ajv, {
+            type: 'object',
+            required: ['$ref'],
+            additionalProperties: false,
+            properties: {
+                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+            },
+        });
+        this.discovery = discovery;
+    }
+    async can_convert_schema_and_raw_data(schema, raw_data) {
+        performance.mark(`${this.constructor.name}.can_convert_schema_and_raw_data() start`);
+        if (!this.can_convert_schema(schema)) {
+            performance.measure(`${this.constructor.name}.can_convert_schema_and_raw_data() early exit`, `${this.constructor.name}.can_convert_schema_and_raw_data() start`);
+            return false;
+        }
+        const maybe = await this.resolve_to_final_converter_schema_only(schema);
+        const [definition, converter] = maybe;
+        const result = await converter.can_convert_schema_and_raw_data(definition, raw_data);
+        performance.measure(`${this.constructor.name}.can_convert_schema_and_raw_data() resolved`, `${this.constructor.name}.can_convert_schema_and_raw_data() start`);
+        return result;
+    }
+    async convert(schema, raw_data) {
+        performance.mark(`${this.constructor.name}.convert() start`);
+        const maybe = await this.resolve_to_final_converter_schema_only(schema);
+        if (undefined === maybe) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, 'No final converter found!');
+        }
+        const [definition, converter,] = maybe;
+        const result = await converter.convert(definition, raw_data);
+        performance.measure(`${this.constructor.name}.convert()`, `${this.constructor.name}.convert() start`);
+        return result;
+    }
+    async resolve_to_final_converter_schema_only(schema) {
+        let checking = schema;
+        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));
+            }
+            if (this.can_convert_schema(checking)) {
+                throw new NoMatchError({
+                    schema,
+                    checking,
+                }, 'Did not resolve past $ref type');
+            }
+            const converter = await Converter.find_matching_schema(await this.discovery.candidates, checking);
+            performance.measure(`${this.constructor.name}.resolve_to_final_converter_schema_only()`, `${this.constructor.name}.resolve_to_final_converter_schema_only() start`);
+            this.cache[schema.$ref] = [checking, converter];
+        }
+        else {
+            performance.measure(`${this.constructor.name}.resolve_to_final_converter_schema_only() cached`, `${this.constructor.name}.resolve_to_final_converter_schema_only() start`);
+        }
+        return this.cache[schema.$ref];
+    }
+}
+//# sourceMappingURL=Ref.js.map

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

@@ -0,0 +1,39 @@
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
+import Ajv, { SchemaObject } from 'ajv/dist/2020';
+import { enum_schema_type } from '../../CustomParsingTypes/TypedStringEnum';
+import { const_schema_type } from '../../CustomParsingTypes/TypedStringConst';
+import { AsExpression, StringLiteral } from 'typescript';
+export type string_schema = {
+    type: 'string';
+    minLength?: number;
+};
+export type pattern_schema = {
+    type: 'string';
+    pattern: string;
+};
+declare abstract class StringConverter<Schema extends SchemaObject> extends ConverterMatchesSchema<Schema, string, StringLiteral> {
+    private readonly maybe_not;
+    protected constructor(ajv: Ajv, schema: SchemaObject);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+}
+export declare class BasicStringConverter extends StringConverter<string_schema> {
+    constructor(ajv: Ajv);
+    convert(_: string_schema, raw_data: string): Promise<ExpressionResult<StringLiteral>>;
+}
+declare abstract class StringConvertHasConstraints<Schema extends SchemaObject> extends StringConverter<Schema> {
+    convert(schema: Schema, raw_data: string): Promise<ExpressionResult<StringLiteral>>;
+}
+export declare class ConstStringConverter extends StringConvertHasConstraints<const_schema_type> {
+    constructor(ajv: Ajv);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+}
+export declare class EnumStringConverter extends StringConvertHasConstraints<enum_schema_type> {
+    constructor(ajv: Ajv);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+}
+export declare class PatternConverter extends ConverterMatchesSchema<pattern_schema, string, AsExpression> {
+    constructor(ajv: Ajv);
+    can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;
+    convert(schema: pattern_schema, raw_data: string): Promise<ExpressionResult<AsExpression>>;
+}
+export {};

package/lib/DataDiscovery/JsonSchema/StringType.js

@@ -0,0 +1,121 @@
+import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { NoMatchError, } from '../../Exceptions';
+import { is_string, } from '../../StringStartsWith';
+import ts from 'typescript';
+import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
+import { object_has_property, value_is_non_array_object, } from '../../CustomParsingTypes/CustomPairingTypes';
+import { not_matching_string_schema, } from '../../TypeDefinitionDiscovery/JsonSchema/String';
+import { compile, } from '../../AjvUtilities';
+class StringConverter extends ConverterMatchesSchema {
+    maybe_not;
+    constructor(ajv, schema) {
+        super(ajv, schema);
+        this.maybe_not = compile(ajv, not_matching_string_schema);
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        if (!is_string(raw_data)
+            || (object_has_property(schema, 'not', value_is_non_array_object)
+                && (!this.maybe_not(schema.not)
+                    || schema.not.enum.includes(raw_data)))) {
+            return Promise.resolve(false);
+        }
+        return Promise.resolve(this.can_convert_schema(schema));
+    }
+}
+export class BasicStringConverter extends StringConverter {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                minLength: { type: 'number', minimum: 0 },
+                not: not_matching_string_schema,
+            },
+        });
+    }
+    convert(_, raw_data) {
+        return Promise.resolve(new ExpressionResult(ts.factory.createStringLiteral(raw_data)));
+    }
+}
+class StringConvertHasConstraints extends StringConverter {
+    async convert(schema, raw_data) {
+        if (!await this.can_convert_schema_and_raw_data(schema, raw_data)) {
+            throw new NoMatchError({
+                schema,
+                raw_data,
+            }, 'Raw data probably did not pass check!');
+        }
+        return Promise.resolve(new ExpressionResult(ts.factory.createStringLiteral(raw_data)));
+    }
+}
+export class ConstStringConverter extends StringConvertHasConstraints {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'const'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                const: { type: 'string' },
+            },
+        });
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(this.can_convert_schema(schema)
+            && is_string(raw_data)
+            && schema.const === raw_data);
+    }
+}
+export class EnumStringConverter extends StringConvertHasConstraints {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'enum'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                enum: {
+                    type: 'array',
+                    minItems: 1,
+                    items: { type: 'string' },
+                },
+            },
+        });
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(this.can_convert_schema(schema)
+            && is_string(raw_data)
+            && schema.enum.includes(raw_data));
+    }
+}
+export class PatternConverter extends ConverterMatchesSchema {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'pattern'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                pattern: { type: 'string', minLength: 2 },
+            },
+        });
+    }
+    can_convert_schema_and_raw_data(schema, raw_data) {
+        return Promise.resolve(this.can_convert_schema(schema)
+            && is_string(raw_data)
+            && (new RegExp(schema.pattern)).test(raw_data));
+    }
+    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 schema!');
+        }
+        return Promise.resolve(new ExpressionResult(ts.factory.createAsExpression(ts.factory.createStringLiteral(raw_data), type_reference_node('StringPassedRegExp', create_literal(schema.pattern)))));
+    }
+}
+//# sourceMappingURL=StringType.js.map

package/lib/DataDiscovery/Literal.d.ts

@@ -0,0 +1,8 @@
+import { ArrayLiteralExpression, Expression, FalseLiteral, Identifier, ObjectLiteralExpression, StringLiteral, TrueLiteral } from 'typescript';
+export declare class Literal {
+    array_literal(from: unknown[]): Promise<ArrayLiteralExpression>;
+    object_literal(from: {
+        [key: string]: unknown;
+    }): Promise<ObjectLiteralExpression>;
+    value_literal(from: unknown): Promise<StringLiteral | TrueLiteral | FalseLiteral | Identifier | ArrayLiteralExpression | Expression | ObjectLiteralExpression>;
+}

package/lib/DataDiscovery/Literal.js

@@ -0,0 +1,69 @@
+import { property_name_or_computed, } from '../TsFactoryWrapper';
+import { NoMatchError, } from '../Exceptions';
+import { ExpressionResult, } from './Generator';
+import { is_string, } from '../StringStartsWith';
+import { value_is_non_array_object, } from '../CustomParsingTypes/CustomPairingTypes';
+import ts from 'typescript';
+export class Literal {
+    async array_literal(from) {
+        const items = [];
+        for (const e of from) {
+            items.push(await this.value_literal(e));
+        }
+        return ts.factory.createArrayLiteralExpression(items);
+    }
+    async object_literal(from) {
+        const properties = [];
+        for (const entry of Object.entries(from)) {
+            try {
+                const value = this.value_literal(entry[1]);
+                properties.push(ts.factory.createPropertyAssignment(property_name_or_computed(entry[0]), await value));
+            }
+            catch (error) {
+                throw new NoMatchError({
+                    property: entry[0],
+                    original_value: entry[1],
+                    error,
+                }, 'Failed to convert property value!');
+            }
+        }
+        return ts.factory.createObjectLiteralExpression(properties);
+    }
+    async value_literal(from) {
+        performance.mark(`${this.constructor.name}.value_literal() start`);
+        if (is_string(from)) {
+            const result = ts.factory.createStringLiteral(from);
+            performance.measure(`${this.constructor.name}.value_literal() createStringLiteral`, `${this.constructor.name}.value_literal() start`);
+            return result;
+        }
+        else if (from instanceof ExpressionResult) {
+            const result = from.expression;
+            performance.measure(`${this.constructor.name}.value_literal() ExpressionResult`, `${this.constructor.name}.value_literal() start`);
+            return result;
+        }
+        if (value_is_non_array_object(from)) {
+            const result = await this.object_literal(from);
+            performance.measure(`${this.constructor.name}.value_literal() object_literal`, `${this.constructor.name}.value_literal() start`);
+            return result;
+        }
+        else if ('boolean' === typeof from) {
+            const result = from
+                ? ts.factory.createTrue()
+                : ts.factory.createFalse();
+            performance.measure(`${this.constructor.name}.value_literal() boolean`, `${this.constructor.name}.value_literal() start`);
+            return result;
+        }
+        else if (undefined === from) {
+            const result = ts.factory.createIdentifier('undefined');
+            performance.measure(`${this.constructor.name}.value_literal() undefined`, `${this.constructor.name}.value_literal() start`);
+            return result;
+        }
+        else if (!(from instanceof Array)) {
+            throw new NoMatchError(from, 'not an array!');
+        }
+        const result = await this.array_literal(from);
+        performance.measure(`${this.constructor.name}.value_literal() array`, `${this.constructor.name}.value_literal() start`);
+        return result;
+    }
+}
+//# sourceMappingURL=Literal.js.map

package/lib/DataDiscovery.d.ts

@@ -0,0 +1,28 @@
+import { DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
+import { GeneratesMarkdown } from './MarkdownUtilities';
+import { Converter } from './DataDiscovery/Generator';
+import { FilesGenerator } from './FilesGenerator';
+import ts from 'typescript';
+import { Literal } from './DataDiscovery/Literal';
+import { SchemaObject } from 'ajv/dist/2020';
+type progress = {
+    [p: string]: string[];
+};
+export declare class DataDiscovery extends FilesGenerator implements GeneratesMarkdown {
+    private readonly progress;
+    readonly candidates: Promise<[
+        Converter<SchemaObject>,
+        ...Converter<SchemaObject>[]
+    ]>;
+    readonly docs: DocsTsGenerator;
+    readonly literal: Literal;
+    constructor(docs: DocsTsGenerator, literal?: Literal);
+    expecting(): Promise<progress>;
+    generate(): Promise<[ts.Expression, DocsDataItem][]>;
+    generate_files(): AsyncGenerator<{
+        file: string;
+        node: ts.VariableStatement;
+    }, void, unknown>;
+    generate_markdown(): Promise<string>;
+}
+export {};

package/lib/DataDiscovery.js

@@ -0,0 +1,116 @@
+import { reduce, remove_indentation, } from './MarkdownUtilities';
+import { Converter, } from './DataDiscovery/Generator';
+import { FilesGenerator, } from './FilesGenerator';
+import { adjust_unrealengine_value, } from './CustomParsingTypes/UnrealEngineString';
+import { adjust_class_name, create_const_statement, create_modifiers, type_reference_node, variable, } from './TsFactoryWrapper';
+import ts from 'typescript';
+import { UnrealEngineString, } from './TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString';
+import { ObjectConverter, PatternedObjectConverter, } from './DataDiscovery/JsonSchema/Object';
+import { ArrayConverter, } from './DataDiscovery/JsonSchema/Array';
+import { BooleanConverter, } from './DataDiscovery/CustomTypes/BooleanOrBooleanExtended';
+import { Literal, } from './DataDiscovery/Literal';
+import { TypedStringConverter, } from './DataDiscovery/CustomTypes/TypedString';
+import { BasicStringConverter, ConstStringConverter, EnumStringConverter, PatternConverter, } from './DataDiscovery/JsonSchema/StringType';
+import { OneOfConverter, } from './DataDiscovery/JsonSchema/OneOf';
+import { StringStartsWithConverter, } from './DataDiscovery/CustomTypes/StringStartsWith';
+import { UnrealEngineStringConverter, } from './DataDiscovery/CustomTypes/UnrealEngineString';
+import { Ref, } from './DataDiscovery/JsonSchema/Ref';
+export class DataDiscovery extends FilesGenerator {
+    progress = {};
+    candidates;
+    docs;
+    literal;
+    constructor(docs, literal) {
+        super();
+        this.docs = docs;
+        this.literal = literal || new Literal();
+        this.candidates = docs.schema().then(({ $defs }) => {
+            return [
+                new BooleanConverter(docs.ajv),
+                new ArrayConverter(this),
+                new BasicStringConverter(docs.ajv),
+                new ConstStringConverter(docs.ajv),
+                new EnumStringConverter(docs.ajv),
+                new PatternConverter(docs.ajv),
+                new StringStartsWithConverter(docs.ajv),
+                new UnrealEngineStringConverter(),
+                new ObjectConverter(this),
+                new PatternedObjectConverter(this),
+                new TypedStringConverter(this, $defs),
+                new OneOfConverter(this),
+                new Ref(this),
+            ];
+        });
+    }
+    async expecting() {
+        const json = await this.docs.get();
+        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(),
+        ]);
+        let index = 0;
+        for (const e of docs) {
+            performance.mark(`${this.constructor.name}.generate() start`);
+            const converter = await Converter.find_matching_schema(await this.candidates, schema.prefixItems[index]);
+            const maybe_result = await this.literal.value_literal(await converter.convert(schema.prefixItems[index], e));
+            performance.measure(`${this.constructor.name}.generate() on item`, `${this.constructor.name}.generate() start`);
+            result.push([maybe_result, e]);
+            ++index;
+        }
+        return result;
+    }
+    async *generate_files() {
+        for (const result of await this.generate()) {
+            const NativeClass_raw = result[1].NativeClass;
+            this.progress[NativeClass_raw] = [];
+            const entry_class_name = adjust_unrealengine_value(UnrealEngineString.fromString(NativeClass_raw).right);
+            const file = `data/CoreUObject/${entry_class_name}.ts`;
+            for (const item of result[1].Classes) {
+                this.progress[NativeClass_raw].push(item.ClassName);
+            }
+            performance.mark(`${this.constructor.name}.generate_files() const generation start`);
+            const result_statement = create_const_statement(variable(adjust_class_name(entry_class_name), result[0], type_reference_node(adjust_class_name(`${entry_class_name}__NativeClass`))));
+            performance.measure(`${this.constructor.name}.generate_files() const generation`, `${this.constructor.name}.generate_files() const generation start`);
+            yield {
+                file,
+                node: ts.factory.updateVariableStatement(result_statement, create_modifiers('export'), result_statement.declarationList),
+            };
+        }
+    }
+    async generate_markdown() {
+        let expected_count = 0;
+        const grouped_progress = {
+            members: [],
+            subgroups: Object.entries(await this.expecting()).reduce((was, is) => {
+                const [NativeClass, Classes] = is;
+                expected_count += 1 + Classes.length;
+                was[NativeClass] = { members: Classes, subgroups: {} };
+                return was;
+            }, {}),
+        };
+        let actual_count = 0;
+        for (const Classes of Object.values(this.progress)) {
+            actual_count += 1 + Classes.length;
+        }
+        return remove_indentation(`
+			# Data Progress
+
+			${((actual_count / expected_count) * 100).toFixed(2)}% Complete (${actual_count} of ${expected_count})
+
+			${reduce(grouped_progress).map((group) => {
+            return remove_indentation(`${'#'.repeat(group.depth)} ${group.title}
+
+					${group.members.map((key) => {
+                const done = (group.title in this.progress
+                    && this.progress[group.title].includes(key));
+                return `-   [${done ? 'x' : ' '}] ${key.replace(/__/g, '\\_\\_')}`;
+            }).join('\n')}`);
+        }).join('\n\n')}
+		`);
+    }
+}
+//# sourceMappingURL=DataDiscovery.js.map

package/lib/DocsToAutoImport/ArrayTypeNodes.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { ArrayTypeNode, Node } from 'typescript';
+export declare class ArrayTypeNodes extends NodeExtraction<ArrayTypeNode> {
+    protected extract(nodes: ArrayTypeNode[]): Node[];
+}

package/lib/DocsToAutoImport/ArrayTypeNodes.js

@@ -0,0 +1,7 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class ArrayTypeNodes extends NodeExtraction {
+    extract(nodes) {
+        return nodes.map((e) => e.elementType);
+    }
+}
+//# sourceMappingURL=ArrayTypeNodes.js.map

package/lib/DocsToAutoImport/ClassDeclarations.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { ClassDeclaration, Node } from 'typescript';
+export declare class ClassDeclarations extends NodeExtraction<ClassDeclaration> {
+    protected extract(nodes: ClassDeclaration[]): Node[];
+}

package/lib/DocsToAutoImport/ClassDeclarations.js

@@ -0,0 +1,14 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class ClassDeclarations extends NodeExtraction {
+    extract(nodes) {
+        return nodes
+            .map((e) => [
+            e.members,
+            e.heritageClauses || [],
+            e.typeParameters || [],
+            e.name ? [e.name] : [],
+        ])
+            .flat(2);
+    }
+}
+//# sourceMappingURL=ClassDeclarations.js.map

package/lib/DocsToAutoImport/FunctionDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { FunctionDeclaration, Node } from 'typescript';
+export declare class FunctionDeclarations extends NodeExtraction<FunctionDeclaration> {
+    extract(nodes: FunctionDeclaration[]): Node[];
+}

package/lib/DocsToAutoImport/FunctionDeclaration.js

@@ -0,0 +1,16 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class FunctionDeclarations extends NodeExtraction {
+    extract(nodes) {
+        return nodes
+            .map((e) => [
+            e.name,
+            ...e.parameters,
+            e.type,
+            ...(e.typeParameters || []),
+            ...(e.body?.statements || []),
+        ])
+            .flat()
+            .filter((maybe) => !!maybe);
+    }
+}
+//# sourceMappingURL=FunctionDeclaration.js.map

package/lib/DocsToAutoImport/LiteralTypeNodes.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { EntityName, LiteralTypeNode } from 'typescript';
+export declare class LiteralTypeNodes extends NodeExtraction<LiteralTypeNode> {
+    protected extract(nodes: LiteralTypeNode[]): EntityName[];
+}

package/lib/DocsToAutoImport/LiteralTypeNodes.js

@@ -0,0 +1,23 @@
+import { NodeExtraction, } from './NodeExtraction';
+import ts from 'typescript';
+import { NoMatchError, } from '../Exceptions';
+export class LiteralTypeNodes extends NodeExtraction {
+    extract(nodes) {
+        if (nodes.length < 1) {
+            return [];
+        }
+        const types = nodes.map((e) => e.literal);
+        const others = [];
+        for (const type of types) {
+            if (type.kind !== ts.SyntaxKind.NullKeyword
+                && type.kind !== ts.SyntaxKind.StringLiteral) {
+                others.push(type);
+            }
+        }
+        if (others.length > 0) {
+            throw new NoMatchError(others, 'Unsupported types found!');
+        }
+        return [];
+    }
+}
+//# sourceMappingURL=LiteralTypeNodes.js.map

package/lib/DocsToAutoImport/MethodDeclarations.d.ts

@@ -0,0 +1,5 @@
+import { NodeExtraction } from './NodeExtraction';
+import { MethodDeclaration, Node } from 'typescript';
+export declare class MethodDeclarations extends NodeExtraction<MethodDeclaration> {
+    extract(nodes: MethodDeclaration[]): Node[];
+}

package/lib/DocsToAutoImport/MethodDeclarations.js

@@ -0,0 +1,15 @@
+import { NodeExtraction, } from './NodeExtraction';
+export class MethodDeclarations extends NodeExtraction {
+    extract(nodes) {
+        return nodes
+            .map((e) => [
+            ...e.parameters,
+            e.type,
+            ...(e.typeParameters || []),
+            ...(e.body?.statements || []),
+        ])
+            .flat()
+            .filter((maybe) => !!maybe);
+    }
+}
+//# sourceMappingURL=MethodDeclarations.js.map

package/lib/DocsToAutoImport/NodeExtraction.d.ts

@@ -0,0 +1,6 @@
+import { EntityName, Node } from 'typescript';
+export declare abstract class NodeExtraction<T extends Node> {
+    readonly results: EntityName[];
+    constructor(nodes: T[]);
+    protected abstract extract(nodes: T[]): Node[];
+}