@satisfactory-dev/docs.json.ts 0.6.1

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

@@ -0,0 +1,91 @@
+import { IntersectionTypeNode, TypeLiteralNode, TypeReferenceNode } from 'typescript';
+import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
+export type RawData = {
+    type: 'object';
+    required?: [string, ...string[]];
+    additionalProperties: false;
+    properties: {
+        [key: string]: unknown;
+    };
+    not?: {
+        anyOf: {
+            [key: string]: unknown;
+        }[];
+    } | {
+        oneOf: {
+            [key: string]: unknown;
+        }[];
+    };
+};
+export declare const schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        $ref: {
+            type: string;
+            pattern: string;
+        };
+        type: {
+            type: string;
+            const: string;
+        };
+        additionalProperties: {
+            type: string;
+            const: boolean;
+        };
+        unevaluatedProperties: {
+            type: string;
+            const: boolean;
+        };
+        required: {
+            type: string;
+            minItems: number;
+            items: {
+                type: string;
+            };
+        };
+        properties: {
+            type: string;
+            minProperties: number;
+        };
+        not: {
+            oneOf: ({
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    oneOf: {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    anyOf?: undefined;
+                };
+            } | {
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    anyOf: {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    oneOf?: undefined;
+                };
+            })[];
+        };
+    };
+};
+type possible = TypeLiteralNode | TypeReferenceNode | IntersectionTypeNode;
+export declare class ObjectType extends GeneratorDoesDiscovery<RawData, possible> {
+    constructor(discovery: TypeDefinitionDiscovery);
+    generate(): (raw_data: RawData) => possible;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/ObjectType.js

@@ -0,0 +1,76 @@
+import ts from 'typescript';
+import { adjust_class_name, create_object_type_from_entries, type_reference_node, } from '../../TsFactoryWrapper';
+import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+import { is_string, } from '../../StringStartsWith';
+export const schema = {
+    type: 'object',
+    required: ['type', 'properties'],
+    additionalProperties: false,
+    properties: {
+        $ref: { type: 'string', pattern: '^#/\\$defs/' },
+        type: { type: 'string', const: 'object' },
+        additionalProperties: { type: 'boolean', const: false },
+        unevaluatedProperties: { type: 'boolean', const: false },
+        required: {
+            type: 'array',
+            minItems: 1,
+            items: { type: 'string' },
+        },
+        properties: { type: 'object', minProperties: 1 },
+        not: {
+            oneOf: [
+                {
+                    type: 'object',
+                    required: ['oneOf'],
+                    additionalProperties: false,
+                    properties: {
+                        oneOf: {
+                            type: 'array',
+                            minItems: 1,
+                            items: { type: 'object' },
+                        },
+                    },
+                },
+                {
+                    type: 'object',
+                    required: ['anyOf'],
+                    additionalProperties: false,
+                    properties: {
+                        anyOf: {
+                            type: 'array',
+                            minItems: 1,
+                            items: { type: 'object' },
+                        },
+                    },
+                },
+            ],
+        },
+    },
+};
+export class ObjectType extends GeneratorDoesDiscovery {
+    constructor(discovery) {
+        super(schema, discovery);
+    }
+    generate() {
+        return (raw_data) => {
+            let type = create_object_type_from_entries(Object.entries(raw_data.properties).map((entry) => {
+                return [
+                    entry[0],
+                    this.discovery.find(entry[1]),
+                ];
+            }), raw_data.required);
+            if ('not' in raw_data) {
+                const exclude = this.discovery.find(raw_data.not);
+                type = type_reference_node('Exclude', type, exclude);
+            }
+            else if ('$ref' in raw_data && is_string(raw_data.$ref)) {
+                type = ts.factory.createIntersectionTypeNode([
+                    type_reference_node(adjust_class_name(`${raw_data.$ref.substring(8)}__type`)),
+                    type,
+                ]);
+            }
+            return type;
+        };
+    }
+}
+//# sourceMappingURL=ObjectType.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Const.d.ts

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

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Const.js

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

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum.d.ts

@@ -0,0 +1,16 @@
+import { Generator } from '../../../Generator';
+import ts, { KeywordTypeNode, UnionTypeNode } from 'typescript';
+import Ajv from 'ajv/dist/2020';
+export type boolean_or_null_type = {
+    type: 'string';
+    enum: ['True', 'False'];
+} | {
+    type: 'string';
+    enum: ['True', 'False', ''];
+};
+type boolean_or_null_return = KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | UnionTypeNode;
+export declare class BooleanEnum extends Generator<boolean_or_null_type, KeywordTypeNode<ts.SyntaxKind.BooleanKeyword> | UnionTypeNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: boolean_or_null_type) => boolean_or_null_return;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum.js

@@ -0,0 +1,47 @@
+import { Generator, } from '../../../Generator';
+import ts from 'typescript';
+import { create_literal, create_union, } from '../../../../TsFactoryWrapper';
+export class BooleanEnum extends Generator {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'enum'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                enum: {
+                    oneOf: [
+                        {
+                            type: 'array',
+                            minItems: 2,
+                            maxItems: 2,
+                            prefixItems: [
+                                { type: 'string', const: 'True' },
+                                { type: 'string', const: 'False' },
+                            ],
+                        },
+                        {
+                            type: 'array',
+                            minItems: 3,
+                            maxItems: 3,
+                            prefixItems: [
+                                { type: 'string', const: 'True' },
+                                { type: 'string', const: 'False' },
+                                { type: 'string', const: '' },
+                            ],
+                        },
+                    ],
+                },
+            },
+        });
+    }
+    generate() {
+        return (raw_data) => {
+            const boolean = ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+            return 2 === raw_data.enum.length
+                ? boolean
+                : create_union(boolean, create_literal(null));
+        };
+    }
+}
+//# sourceMappingURL=BooleanEnum.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum.d.ts

@@ -0,0 +1,40 @@
+import { Generator } from '../../Generator';
+import Ajv from 'ajv/dist/2020';
+import { LiteralTypeNode, StringLiteral, UnionTypeNode } from 'typescript';
+type RawData = {
+    type: 'string';
+    enum: [string, ...string[]];
+};
+type Type = UnionTypeNode & {
+    types: [
+        (LiteralTypeNode & {
+            literal: StringLiteral;
+        }),
+        ...(LiteralTypeNode & {
+            literal: StringLiteral;
+        })[]
+    ];
+};
+export declare const schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        enum: {
+            type: string;
+            minItems: number;
+            items: {
+                type: string;
+            };
+        };
+    };
+};
+export declare class Enum extends Generator<RawData, Type> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: RawData) => Type;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Enum.js

@@ -0,0 +1,22 @@
+import { Generator, } from '../../Generator';
+import { create_typed_union, } from '../../../TsFactoryWrapper';
+export const schema = {
+    type: 'object',
+    required: ['type', 'enum'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        enum: { type: 'array', minItems: 1, items: { type: 'string' } },
+    },
+};
+export class Enum extends Generator {
+    constructor(ajv) {
+        super(ajv, schema);
+    }
+    generate() {
+        return (raw_data) => {
+            return create_typed_union(raw_data.enum);
+        };
+    }
+}
+//# sourceMappingURL=Enum.js.map

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Pattern.d.ts

@@ -0,0 +1,13 @@
+import Ajv from 'ajv/dist/2020';
+import { TypeReferenceNode } from 'typescript';
+import { Generator } from '../../Generator';
+export declare class Pattern extends Generator<{
+    type: 'string';
+    pattern: string;
+}, TypeReferenceNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: {
+        type: 'string';
+        pattern: string;
+    }) => TypeReferenceNode;
+}

package/lib/TypeDefinitionDiscovery/JsonSchema/String/Pattern.js

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

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

@@ -0,0 +1,52 @@
+import { Generator } from '../Generator';
+import { KeywordTypeNode, TypeReferenceNode } from 'typescript';
+import Ajv from 'ajv/dist/2020';
+export declare class StringType extends Generator<{
+    type: 'string';
+}, KeywordTypeNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: {
+        type: 'string';
+    }) => KeywordTypeNode;
+}
+export declare class NonEmptyString extends Generator<{
+    type: 'string';
+    minLength: 1;
+}, TypeReferenceNode> {
+    constructor(ajv: Ajv);
+    generate(): () => TypeReferenceNode;
+}
+export type not_matching_string_type = {
+    type: 'string';
+    enum: [string, ...string[]];
+};
+type RawDataNonEmptyWithExclusions = {
+    type: 'string';
+    minLength: 1;
+    not: not_matching_string_type;
+};
+export declare const not_matching_string_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        enum: {
+            type: string;
+            minItems: number;
+            uniqueItems: boolean;
+            items: {
+                type: string;
+                minLength: number;
+            };
+        };
+    };
+};
+export declare class NonEmptyStringWithExclusions extends Generator<RawDataNonEmptyWithExclusions, TypeReferenceNode> {
+    constructor(ajv: Ajv);
+    generate(): (raw_data: RawDataNonEmptyWithExclusions) => TypeReferenceNode;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/String.js

@@ -0,0 +1,72 @@
+import { Generator, } from '../Generator';
+import { create_literal, create_type, possibly_create_lazy_union, type_reference_node, } from '../../TsFactoryWrapper';
+export class StringType extends Generator {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                minLength: { type: 'number', minimum: 0, not: { const: 1 } },
+            },
+        });
+    }
+    generate() {
+        return () => create_type('string');
+    }
+}
+export class NonEmptyString extends Generator {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'minLength'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                minLength: { type: 'number', const: 1 },
+            },
+        });
+    }
+    generate() {
+        return () => type_reference_node('Exclude', create_type('string'), create_literal(''));
+    }
+}
+export const not_matching_string_schema = {
+    type: 'object',
+    required: ['type', 'enum'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        enum: {
+            type: 'array',
+            minItems: 1,
+            uniqueItems: true,
+            items: {
+                type: 'string',
+                minLength: 1,
+            },
+        },
+    },
+};
+export class NonEmptyStringWithExclusions extends Generator {
+    constructor(ajv) {
+        super(ajv, {
+            type: 'object',
+            required: ['type', 'minLength'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                minLength: { type: 'number', const: 1 },
+                not: not_matching_string_schema,
+            },
+        });
+    }
+    generate() {
+        return (raw_data) => type_reference_node('Exclude', create_type('string'), possibly_create_lazy_union([
+            '',
+            ...raw_data.not.enum,
+        ]));
+    }
+}
+//# sourceMappingURL=String.js.map

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

@@ -0,0 +1,63 @@
+import { UnionTypeNode } from 'typescript';
+import { GeneratorDoesDiscovery } from '../GeneratorDoesDiscovery';
+import { TypeDefinitionDiscovery } from '../../TypeDefinitionDiscovery';
+type RawData = {
+    oneOf: [
+        {
+            [key: string]: unknown;
+        },
+        ...{
+            [key: string]: unknown;
+        }[]
+    ];
+} | {
+    anyOf: [
+        {
+            [key: string]: unknown;
+        },
+        ...{
+            [key: string]: unknown;
+        }[]
+    ];
+};
+export declare const schema: {
+    oneOf: ({
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            type: {
+                type: string;
+                const: string;
+            };
+            oneOf: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                };
+            };
+            anyOf?: undefined;
+        };
+    } | {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            anyOf: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                };
+            };
+            type?: undefined;
+            oneOf?: undefined;
+        };
+    })[];
+};
+export declare class oneOf_or_anyOf extends GeneratorDoesDiscovery<RawData, UnionTypeNode> {
+    constructor(discovery: TypeDefinitionDiscovery);
+    generate(): (raw_data: RawData) => UnionTypeNode;
+}
+export {};

package/lib/TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf.js

@@ -0,0 +1,47 @@
+import ts from 'typescript';
+import { GeneratorDoesDiscovery, } from '../GeneratorDoesDiscovery';
+export const schema = {
+    oneOf: [
+        {
+            type: 'object',
+            required: ['oneOf'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                oneOf: {
+                    type: 'array',
+                    minItems: 1,
+                    items: { type: 'object' },
+                },
+            },
+        },
+        {
+            type: 'object',
+            required: ['anyOf'],
+            additionalProperties: false,
+            properties: {
+                anyOf: {
+                    type: 'array',
+                    minItems: 1,
+                    items: { type: 'object' },
+                },
+            },
+        },
+    ],
+};
+export class oneOf_or_anyOf extends GeneratorDoesDiscovery {
+    constructor(discovery) {
+        super(schema, discovery);
+    }
+    generate() {
+        return (raw_data) => {
+            const source = 'oneOf' in raw_data
+                ? raw_data.oneOf
+                : raw_data.anyOf;
+            return ts.factory.createUnionTypeNode(source.map((e) => {
+                return this.discovery.find(e);
+            }));
+        };
+    }
+}
+//# sourceMappingURL=oneOf_or_anyOf.js.map

package/lib/TypeDefinitionDiscovery.d.ts

@@ -0,0 +1,49 @@
+import Ajv from 'ajv/dist/2020';
+import { TypesDiscovery } from './TypesDiscovery';
+import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
+import ts, { TypeNode } from 'typescript';
+import { AnyGenerator } from './TypeDefinitionDiscovery/Generator';
+import { FilesGenerator } from './FilesGenerator';
+import { DocsTsGenerator } from './DocsTsGenerator';
+import { GeneratesMarkdown } from './MarkdownUtilities';
+export type ref_discovery_type = {
+    found_types: {
+        [key: string]: (raw_data: unknown) => TypeNode;
+    };
+    missing_types: string[];
+    found_classes: {
+        [key: string]: unknown;
+    }[];
+    missing_classes: {
+        [key: string]: unknown;
+    }[];
+};
+export declare class TypeDefinitionDiscovery extends FilesGenerator implements GeneratesMarkdown {
+    private $ref_discovery;
+    private readonly candidates;
+    readonly docs: DocsTsGenerator;
+    readonly types_discovery: TypesDiscovery;
+    constructor(types_discovery: [
+        CandidatesDiscovery,
+        ...CandidatesDiscovery[]
+    ], type_definition_discover: [
+        AnyGenerator,
+        ...AnyGenerator[]
+    ], docs: DocsTsGenerator);
+    add_candidates(...candidates: AnyGenerator[]): void;
+    discover_type_$defs(): Promise<ref_discovery_type>;
+    find(maybe: unknown): TypeNode;
+    generate_files(): AsyncGenerator<{
+        file: string;
+        node: ts.TypeAliasDeclaration;
+    }, void, unknown>;
+    generate_markdown(): Promise<string>;
+    private discover_type_definitions_from;
+    /**
+     * @todo move to DocsTsGenerator
+     */
+    private schema_from_json;
+    private search;
+    static custom_parsing_discovery(ajv: Ajv): [AnyGenerator, ...AnyGenerator[]];
+    static standard_jsonschema_discovery(ajv: Ajv): [AnyGenerator, ...AnyGenerator[]];
+}