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

package/lib/DocsTsGenerator.js

@@ -5,14 +5,13 @@ import { fileURLToPath, } from 'node:url';
 import * as prettier from 'prettier';
 import standalone from 'ajv/dist/standalone';
 import { ESLint, } from 'eslint';
-import update8_schema from '../schema/update8.schema.json' with {
-    type: 'json'
-};
 import { createHash, } from 'node:crypto';
 import { is_non_empty_array, is_string, object_has_only_properties_that_match_predicate, object_has_property, property_exists_on_object, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import { NoMatchError, } from './Exceptions';
 import { TypedString, } from './CustomParsingTypes/TypedString';
 import { compile, esmify, } from '@satisfactory-dev/ajv-utilities';
+import { DocsSchemaByVersion, } from './DocsSchema';
+import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export class ValidationError extends Error {
     errors;
@@ -23,12 +22,29 @@ export class ValidationError extends Error {
         this.json = json;
     }
 }
-export class DocsTsGenerator {
+export class DocsTsGeneratorVersion {
     docs;
     cache_path;
     docs_path;
-    ajv;
     types_from_module;
+    // eslint-disable-next-line max-len
+    UnrealEngineString_quote_mode;
+    constructor({ 
+    // raw JSON or path to UTF-16LE encoded Docs.json
+    docs_path, 
+    // optional cache folder path for cacheable resources
+    cache_path = undefined, UnrealEngineString_quote_mode, types_from_module = undefined, }) {
+        this.cache_path = cache_path;
+        this.docs_path = docs_path;
+        this.UnrealEngineString_quote_mode = UnrealEngineString_quote_mode;
+        this.types_from_module = types_from_module;
+    }
+}
+export class DocsTsGenerator {
+    // eslint-disable-next-line max-len
+    schema_data = new DocsSchemaByVersion();
+    ajv;
+    docs_versions;
     static PERF_EARLY_RETURN = 'Early Return of Docs.json';
     static PERF_FAILURE = 'Failure to load Docs.json';
     static PERF_FILE_PARSED = 'Docs.json contents parsed';
@@ -41,17 +57,16 @@ export class DocsTsGenerator {
     constructor({ 
     // Ajv instance
     ajv, 
-    // raw JSON or path to UTF-16LE encoded Docs.json
-    docs_path, 
-    // optional cache folder path for cacheable resources
-    cache_path = undefined, types_from_module = undefined, }) {
+    // Docs object
+    docs_versions, }) {
+        if (Object.keys(docs_versions).length < 1) {
+            throw new Error('No versions specified!');
+        }
         this.ajv = ajv;
-        this.docs_path = docs_path;
-        this.cache_path = cache_path;
-        this.types_from_module = types_from_module;
+        this.docs_versions = docs_versions;
     }
-    async definition($ref) {
-        const schema = await this.schema();
+    async definition(version, $ref) {
+        const schema = await this.schema(version);
         if (!property_exists_on_object(schema.$defs, $ref)) {
             throw new NoMatchError({
                 $ref,
@@ -60,30 +75,53 @@ export class DocsTsGenerator {
         }
         return schema.$defs[$ref];
     }
-    async get() {
-        return this.validate(await this.load(), await this.schema());
+    async get(version) {
+        return this.validate(version, await this.load(version), await this.schema(version));
     }
-    async schema() {
-        await this.validate_schema(update8_schema);
-        return update8_schema;
+    schema(version) {
+        if ('update8' === version) {
+            return this.schema_update8();
+        }
+        else if ('version_1_0_0_0' === version) {
+            return this.schema_version_1_0_0_0();
+        }
+        throw new Error('Could not find specified schema!');
+    }
+    // eslint-disable-next-line max-len
+    async schema_update8() {
+        const schema = this.schema_data.update8.en_US.schema;
+        // eslint-disable-next-line max-len
+        await this.validate_schema('update8', schema);
+        return schema;
     }
-    async load() {
-        if (undefined === this.docs) {
+    // eslint-disable-next-line max-len
+    async schema_version_1_0_0_0() {
+        const schema = this.schema_data.version_1_0_0_0.en_US.schema;
+        // eslint-disable-next-line max-len
+        await this.validate_schema('version_1_0_0_0', schema);
+        return schema;
+    }
+    async load(version) {
+        const docs = this.docs_versions[version];
+        if (undefined === docs) {
+            throw new Error('Requested version not configured!');
+        }
+        if (undefined === docs.docs) {
             performance.mark(DocsTsGenerator.PERF_START_LOADING_JSON);
-            if ('string' !== typeof this.docs_path) {
+            if ('string' !== typeof docs.docs_path) {
                 performance.measure(DocsTsGenerator.PERF_EARLY_RETURN, DocsTsGenerator.PERF_START_LOADING_JSON);
-                return this.docs_path;
+                return docs.docs_path;
             }
-            else if (!this.docs_path.endsWith('.json')) {
+            else if (!docs.docs_path.endsWith('.json')) {
                 performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
                 throw new Error('Probably not a JSON file');
             }
             else {
                 let maybe_json;
                 try {
-                    if (this.cache_path) {
-                        const utf8_filename = basename(this.docs_path).replace(/\.json$/, '.utf8.json');
-                        const utf8_filepath = `${this.cache_path}/${utf8_filename}`;
+                    if (docs.cache_path) {
+                        const utf8_filename = basename(docs.docs_path).replace(/\.json$/, '.utf8.json');
+                        const utf8_filepath = `${docs.cache_path}/${utf8_filename}`;
                         if (existsSync(utf8_filepath)) {
                             const file_contents = await readFile(utf8_filepath);
                             performance.measure(DocsTsGenerator.PERF_FILE_READ, DocsTsGenerator.PERF_START_LOADING_JSON);
@@ -91,13 +129,13 @@ export class DocsTsGenerator {
                             performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
                         }
                         else {
-                            maybe_json = await this.load_from_file(this.docs_path);
+                            maybe_json = await this.load_from_file(docs.docs_path);
                             performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
                             await writeFile(utf8_filepath, JSON.stringify(maybe_json, null, '\t') + '\n');
                         }
                     }
                     else {
-                        maybe_json = await this.load_from_file(this.docs_path);
+                        maybe_json = await this.load_from_file(docs.docs_path);
                         performance.measure(DocsTsGenerator.PERF_FILE_PARSED, DocsTsGenerator.PERF_START_LOADING_JSON);
                     }
                 }
@@ -109,13 +147,13 @@ export class DocsTsGenerator {
                     performance.measure(DocsTsGenerator.PERF_FAILURE, DocsTsGenerator.PERF_START_LOADING_JSON);
                     throw new Error('Was expecting json to be an array!');
                 }
-                this.docs = maybe_json;
+                docs.docs = maybe_json;
             }
-            if (undefined === this.docs) {
-                throw new Error('this.docs not set!');
+            if (undefined === docs.docs) {
+                throw new Error('docs not set!');
             }
         }
-        return this.docs;
+        return docs.docs;
     }
     async load_from_file(filepath) {
         const file = await readFile(filepath, {
@@ -125,18 +163,22 @@ export class DocsTsGenerator {
         const utf8 = Buffer.from(file).toString('utf-8');
         return JSON.parse(utf8.trim());
     }
-    async validate(json, schema) {
+    async validate(version, json, schema) {
         performance.mark(DocsTsGenerator.PERF_VALIDATION_STARTED);
-        const validateDocs = await this.validate_schema(schema);
+        const validateDocs = await this.validate_schema(version, schema);
         performance.measure(DocsTsGenerator.PERF_VALIDATION_COMPILED, DocsTsGenerator.PERF_VALIDATION_STARTED);
         const result = validateDocs(json);
         performance.measure(DocsTsGenerator.PERF_VALIDATION_FINISHED, DocsTsGenerator.PERF_VALIDATION_STARTED);
         if (!result) {
-            throw new ValidationError('Failed to validate against the provided JSON Schema', validateDocs.errors, json);
+            throw new ValidationError(`Failed to validate ${version} against the provided JSON Schema`, validateDocs.errors, json);
         }
         return json;
     }
-    async validate_schema(schema) {
+    async validate_schema(version, schema) {
+        const docs = this.docs_versions[version];
+        if (undefined === docs) {
+            throw new Error('Requested version not configured!');
+        }
         if (object_has_property(schema, '$defs', value_is_non_array_object)
             && object_has_only_properties_that_match_predicate(schema.$defs, value_is_non_array_object)) {
             const { $defs } = schema;
@@ -144,17 +186,19 @@ export class DocsTsGenerator {
                 TypedString.instance().configure_ajv($defs, this.ajv);
             }
         }
-        if (this.cache_path) {
+        if (docs.cache_path) {
             const file_sha512 = createHash('sha512');
             if (!object_has_property(schema, '$id', is_string)) {
                 throw new ValidationError('Schema does not have an id!', undefined, schema);
             }
             file_sha512.update(await readFile(`${__dirname}/../schema/${schema['$id']}`));
             const filename = `${schema['$id']}.${file_sha512.digest('hex')}.mjs`;
-            const filepath = `${this.cache_path}/${filename}`;
+            const filepath = `${docs.cache_path}/${filename}`;
             if (!existsSync(filepath)) {
                 performance.mark(DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
                 performance.measure('ajv configured', DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
+                // eslint-disable-next-line max-len
+                UnrealEngineString.quote_mode = docs.UnrealEngineString_quote_mode;
                 await writeFile(filepath, esmify(standalone(this.ajv, compile(this.ajv, schema))));
                 performance.measure('ajv pre-compilation done', DocsTsGenerator.PERF_VALIDATION_PRECOMPILE, DocsTsGenerator.PERF_VALIDATION_PRECOMPILE);
             }

package/lib/TsFactoryWrapper.d.ts

@@ -39,7 +39,7 @@ declare const type_map: {
     unknown: ts.SyntaxKind;
 };
 export declare function create_type(type: keyof typeof type_map): ts.KeywordTypeNode;
-export declare function create_object_type_from_entries(entries: [string, TypeNode][], required?: [string, ...string[]]): TypeLiteralNode;
+export declare function create_object_type_from_entries(entries: [string, TypeNode][], required?: [string, ...string[]], default_required?: boolean): TypeLiteralNode;
 export declare function createPropertySignature(property: string, type: TypeNode, required?: boolean): PropertySignature;
 export declare function needs_element_access(property: string): boolean;
 export declare function computed_property_name_or_undefined(property: string): ts.ComputedPropertyName | undefined;

package/lib/TsFactoryWrapper.js

@@ -7,7 +7,7 @@ export function adjust_class_name(class_name) {
     if ('class' === class_name) {
         return 'Docs_class';
     }
-    return class_name.replace(/[^A-Za-z_\d]/g, '_');
+    return class_name.replace(/[^A-Za-z_\d ]/g, '_');
 }
 export const modifier_map = {
     abstract: () => {
@@ -130,10 +130,10 @@ const type_map = {
 export function create_type(type) {
     return ts.factory.createKeywordTypeNode(type_map[type]);
 }
-export function create_object_type_from_entries(entries, required) {
+export function create_object_type_from_entries(entries, required, default_required = true) {
     return ts.factory.createTypeLiteralNode(entries.map((entry) => {
         const [property, type] = entry;
-        return createPropertySignature(property, type, required ? required.includes(property) : true);
+        return createPropertySignature(property, type, required ? required.includes(property) : default_required);
     }));
 }
 export function createPropertySignature(property, type, required = true) {
@@ -142,7 +142,7 @@ export function createPropertySignature(property, type, required = true) {
         : ts.factory.createToken(ts.SyntaxKind.QuestionToken), type);
 }
 export function needs_element_access(property) {
-    return /[?[\]]/.test(property);
+    return /[?[\] ]/.test(property);
 }
 export function computed_property_name_or_undefined(property) {
     return needs_element_access(property)

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -1,5 +1,5 @@
 import { Generator, } from '../Generator';
-import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
+import { UnrealEngineString_parent_schema, UnrealEngineString_reference_type, UnrealEngineString_regex, UnrealEngineString_regex_quoted, UnrealEngineString_schema_definitions, } from '../../CustomParsingTypes/UnrealEngineString';
 export class UnrealEngineString extends Generator {
     constructor(ajv) {
         super(ajv, {
@@ -13,7 +13,10 @@ export class UnrealEngineString extends Generator {
         };
     }
     static fromString(value) {
-        const result = UnrealEngineString_regex.exec(value);
+        let result = UnrealEngineString_regex.exec(value);
+        if (!result) {
+            result = UnrealEngineString_regex_quoted.exec(value);
+        }
         if (!result) {
             throw new Error(`Not an UnrealEngineString (${value})`);
         }

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

@@ -1,14 +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 { typed_string_inner_array_prefixItems_type, typed_string_inner_array_type, typed_string_inner_object_pattern_type, typed_string_inner_object_type, typed_string_inner_object_type_no_required, 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;
+    static is_array_type(maybe: typed_string_inner_object_type_no_required | 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_no_required | 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_no_required | 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 | typed_string_inner_object_type_no_required);
+    static is_prefixItems_type(maybe: typed_string_inner_object_type_no_required | 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

@@ -76,7 +76,9 @@ export class typed_string extends GeneratorDoesDiscovery {
                     entry[0],
                     this.discovery.find(entry[1]),
                 ];
-            }), typed_string_value.required);
+            }), ('required' in typed_string_value
+                ? typed_string_value.required
+                : undefined), false);
         };
     }
     static is_array_type(maybe) {

package/lib/TypeDefinitionDiscovery.d.ts

@@ -4,7 +4,7 @@ import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
 import ts, { TypeNode } from 'typescript';
 import { AnyGenerator } from './TypeDefinitionDiscovery/Generator';
 import { FilesGenerator } from './FilesGenerator';
-import { DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
 import { GeneratesMarkdown } from './MarkdownUtilities';
 export type ref_discovery_type = {
     found_types: {
@@ -21,6 +21,7 @@ export type ref_discovery_type = {
 export declare class TypeDefinitionDiscovery extends FilesGenerator implements GeneratesMarkdown {
     private $ref_discovery;
     private readonly candidates;
+    private readonly version;
     readonly docs: DocsTsGenerator;
     readonly types_discovery: TypesDiscovery;
     constructor(types_discovery: [
@@ -29,7 +30,7 @@ export declare class TypeDefinitionDiscovery extends FilesGenerator implements G
     ], type_definition_discover: [
         AnyGenerator,
         ...AnyGenerator[]
-    ], docs: DocsTsGenerator);
+    ], docs: DocsTsGenerator, version: keyof docs_versions);
     add_candidates(...candidates: AnyGenerator[]): void;
     discover_type_$defs(): Promise<ref_discovery_type>;
     find(maybe: unknown): TypeNode;

package/lib/TypeDefinitionDiscovery.js

@@ -28,13 +28,15 @@ function is_schema_with_$defs(schema, discovered_types) {
 export class TypeDefinitionDiscovery extends FilesGenerator {
     $ref_discovery;
     candidates;
+    version;
     docs;
     types_discovery;
-    constructor(types_discovery, type_definition_discover, docs) {
+    constructor(types_discovery, type_definition_discover, docs, version) {
         super();
-        this.types_discovery = new TypesDiscovery(types_discovery, docs);
+        this.types_discovery = new TypesDiscovery(types_discovery, docs, version);
         this.candidates = type_definition_discover;
         this.docs = docs;
+        this.version = version;
     }
     add_candidates(...candidates) {
         this.candidates.push(...candidates);
@@ -69,7 +71,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
             const target_file = guess_filename($ref);
             yield {
                 file: target_file,
-                node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), adjust_class_name(`${$ref}__type`), undefined, generator(await this.docs.definition($ref))),
+                node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), adjust_class_name(`${$ref}__type`), undefined, generator(await this.docs.definition(this.version, $ref))),
             };
         }
     }
@@ -177,7 +179,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         if (object_has_non_empty_array_property(schema, 'prefixItems', value_is_non_array_object)) {
             const native_class = compile(this.docs.ajv, {
                 type: 'object',
-                required: ['type', '$ref', 'properties'],
+                required: ['$comment', 'type', '$ref', 'properties'],
                 additionalProperties: false,
                 $defs: {
                     $ref_base: {
@@ -209,6 +211,11 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                     },
                 },
                 properties: {
+                    $comment: {
+                        type: 'string',
+                        // eslint-disable-next-line max-len
+                        pattern: '^\\/Script\\/CoreUObject\\.Class\'\\/Script\\/FactoryGame\\.',
+                    },
                     type: { type: 'string', const: 'object' },
                     $ref: { type: 'string', const: '#/$defs/NativeClass' },
                     unevaluatedProperties: { type: 'boolean', const: false },
@@ -313,12 +320,49 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                                             },
                                         },
                                     },
+                                    {
+                                        type: 'object',
+                                        required: [
+                                            'type',
+                                            'prefixItems',
+                                            'minItems',
+                                        ],
+                                        additionalProperties: false,
+                                        properties: {
+                                            type: {
+                                                type: 'string',
+                                                const: 'array',
+                                            },
+                                            minItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            maxItems: {
+                                                type: 'number',
+                                                minimum: 1,
+                                            },
+                                            items: {
+                                                type: 'boolean',
+                                                const: false,
+                                            },
+                                            prefixItems: {
+                                                type: 'array',
+                                                minItems: 1,
+                                                items: {
+                                                    $ref: '#/$defs/$ref',
+                                                },
+                                            },
+                                        },
+                                    },
                                 ] } },
                     },
                 },
             });
             for (const item of schema.prefixItems) {
                 if (native_class(item)) {
+                    if ('$comment' in item) {
+                        delete item.$comment;
+                    }
                     result.found_classes.push(item);
                 }
                 else {
@@ -338,7 +382,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
      * @todo move to DocsTsGenerator
      */
     async schema_from_json(discovered_types) {
-        const schema = await this.docs.schema();
+        const schema = await this.docs.schema(this.version);
         if (!is_schema_with_$defs(schema, discovered_types)) {
             throw new Error('Schema $defs not as expected!');
         }

package/lib/TypeDefinitionWriter.d.ts

@@ -1,6 +1,6 @@
 import { TypeDefinitionDiscovery } from './TypeDefinitionDiscovery';
 import ts, { ClassDeclaration } from 'typescript';
-import { DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
 type class_can_have_tree = ClassDeclaration & {
     heritageClauses: [{
         types: [{
@@ -13,7 +13,8 @@ export declare class TypeDefinitionWriter {
     private prepared;
     private readonly data_discovery;
     private readonly docs;
-    constructor(docs: DocsTsGenerator);
+    private readonly version;
+    constructor(docs: DocsTsGenerator, version: keyof docs_versions);
     get discovery(): Promise<TypeDefinitionDiscovery>;
     write(parent_folder: string, cleanup?: boolean): Promise<void>;
     private prepare;

package/lib/TypeDefinitionWriter.js

@@ -26,13 +26,15 @@ export class TypeDefinitionWriter {
     prepared = false;
     data_discovery;
     docs;
-    constructor(docs) {
+    version;
+    constructor(docs, version) {
         this.docs = docs;
-        this.data_discovery = new DataDiscovery(docs);
+        this.data_discovery = new DataDiscovery(docs, version);
+        this.version = version;
     }
     get discovery() {
         if (!this._discovery) {
-            const schema = this.docs.schema();
+            const schema = this.docs.schema(this.version);
             const type_definition_discover = require_non_empty_array([
                 ...TypeDefinitionDiscovery.standard_jsonschema_discovery(this.docs.ajv),
                 ...TypeDefinitionDiscovery.custom_parsing_discovery(this.docs.ajv),
@@ -41,7 +43,7 @@ export class TypeDefinitionWriter {
                 return new TypeDefinitionDiscovery([
                     ...TypesDiscovery.standard_jsonschema_discovery(schema),
                     ...TypesDiscovery.custom_parsing_types(schema),
-                ], type_definition_discover, this.docs);
+                ], type_definition_discover, this.docs, this.version);
             }));
         }
         return this._discovery;
@@ -54,8 +56,8 @@ export class TypeDefinitionWriter {
         const discovery = await this.discovery;
         performance.measure(`${this.constructor.name}.write() discovery`, `${this.constructor.name}.write() start`);
         performance.mark(`${this.constructor.name}.write() start`);
-        await writeFile(`${__dirname}/../types-progress.md`, await discovery.generate_markdown());
-        await writeFile(`${__dirname}/../data-progress.md`, await this.data_discovery.generate_markdown());
+        await writeFile(`${__dirname}/../types-progress--${this.version}.md`, await discovery.generate_markdown());
+        await writeFile(`${__dirname}/../data-progress--${this.version}.md`, await this.data_discovery.generate_markdown());
         performance.measure(`${this.constructor.name}.write() generate_markdown`, `${this.constructor.name}.write() start`);
         if (cleanup) {
             performance.mark(`${this.constructor.name}.write() start`);
@@ -66,7 +68,7 @@ export class TypeDefinitionWriter {
         }
         performance.mark(`${this.constructor.name}.write() start`);
         const types = await discovery.discover_type_$defs();
-        const schema = await this.docs.schema();
+        const schema = await this.docs.schema(this.version);
         if (types.missing_classes.length > 0
             || types.missing_types.length > 0) {
             throw new NoMatchError({
@@ -88,7 +90,7 @@ export class TypeDefinitionWriter {
         }
         const files = await FilesGenerator.merge_files([
             discovery,
-            new DocsFiles(validations, discovery),
+            new DocsFiles(validations, discovery, this.version),
             new FromArray([
                 ...legacy_UnrealEngineString_module.CustomGenerators(),
                 string_starts_with,
@@ -101,7 +103,7 @@ export class TypeDefinitionWriter {
         const auto_imports = new DocsTsAutoImports(files);
         const import_tracker = auto_imports.generate();
         performance.measure(`${this.constructor.name}.write() auto_imports`, `${this.constructor.name}.write() start`);
-        await writeFile(`${__dirname}/../imports-come-from.json`, auto_imports.imports_come_from);
+        await writeFile(`${__dirname}/../imports-come-from.${this.version}.json`, auto_imports.imports_come_from);
         const printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,
         });
@@ -204,14 +206,15 @@ export class TypeDefinitionWriter {
             }
             let code = await format_code(node_strings
                 .join('\n\n'));
-            if (this.docs.types_from_module) {
-                code = code.replace(/} from '(?:\.\.\/)+(classes|common|utils)\//g, `} from '${this.docs.types_from_module}/$1/`);
+            const types_from_module = this.docs.docs_versions[this.version]?.types_from_module;
+            if (types_from_module) {
+                code = code.replace(/} from '(?:\.\.\/)+(classes|common|utils)\//g, `} from '${types_from_module}/$1/`);
             }
             await writeFile(file_name, code);
         }
         performance.measure(`${this.constructor.name}.write() actually write files`, `${this.constructor.name}.write() start`);
         performance.mark(`${this.constructor.name}.write() start`);
-        await writeFile(`${__dirname}/../data-progress.md`, await this.data_discovery.generate_markdown());
+        await writeFile(`${__dirname}/../data-progress--${this.version}.md`, await this.data_discovery.generate_markdown());
         performance.measure(`${this.constructor.name}.write() generate_markdown`, `${this.constructor.name}.write() start`);
         performance.mark(`${this.constructor.name}.write() start`);
         await eslint_generated_types(parent_folder);

package/lib/TypesDiscovery.d.ts

@@ -1,12 +1,13 @@
 import { SchemaObject } from 'ajv/dist/2020';
 import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
-import { DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
+import { docs_versions, DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
 import { local_ref } from './StringStartsWith';
 export declare class TypesDiscovery {
     private discovery;
     private readonly candidates_discovery;
     private readonly docs;
-    constructor(candidates_discovery: [CandidatesDiscovery, ...CandidatesDiscovery[]], docs: DocsTsGenerator);
+    private readonly version;
+    constructor(candidates_discovery: [CandidatesDiscovery, ...CandidatesDiscovery[]], docs: DocsTsGenerator, version: keyof docs_versions);
     discover_types(): Promise<{
         discovered_types: local_ref<string>[];
         missed_types: string[];
@@ -16,7 +17,7 @@ export declare class TypesDiscovery {
         CandidatesDiscovery,
         ...CandidatesDiscovery[]
     ]);
-    static generate_is_NativeClass(docs: DocsTsGenerator): Promise<import("ajv/dist/types").ValidateFunction<DocsDataItem>>;
+    static generate_is_NativeClass(docs: DocsTsGenerator, version: keyof docs_versions): Promise<import("ajv/dist/types").ValidateFunction<DocsDataItem>>;
     static standard_jsonschema_discovery(schema: SchemaObject): ([
         CandidatesDiscovery,
         ...CandidatesDiscovery[]

package/lib/TypesDiscovery.js

@@ -13,13 +13,15 @@ export class TypesDiscovery {
     discovery;
     candidates_discovery;
     docs;
-    constructor(candidates_discovery, docs) {
+    version;
+    constructor(candidates_discovery, docs, version) {
         this.candidates_discovery = candidates_discovery;
         this.docs = docs;
+        this.version = version;
     }
     async discover_types() {
         if (!this.discovery) {
-            const schema = await this.docs.schema();
+            const schema = await this.docs.schema(this.version);
             const discovered_types = new Set();
             this.discover_types_from(schema, schema, discovered_types);
             this.discovery = Promise.resolve({
@@ -48,8 +50,8 @@ export class TypesDiscovery {
             new typed_string(schema),
         ];
     }
-    static async generate_is_NativeClass(docs) {
-        const schema = await docs.schema();
+    static async generate_is_NativeClass(docs, version) {
+        const schema = await docs.schema(version);
         if (!object_has_property(schema, '$defs', value_is_non_array_object)) {
             throw new Error('Schema appears to have no $defs');
         }

package/lib/helpers.js

@@ -1,5 +1,5 @@
 import { existsSync, } from 'node:fs';
-import { DocsTsGenerator, } from './DocsTsGenerator';
+import { DocsTsGenerator, DocsTsGeneratorVersion, } from './DocsTsGenerator';
 import { __dirname_from_meta, } from './__dirname';
 import Ajv from 'ajv/dist/2020';
 import { configure_ajv, } from './DocsValidation';
@@ -18,11 +18,21 @@ const ajv = new Ajv({
 configure_ajv(ajv);
 export const docs = new DocsTsGenerator({
     ajv,
-    docs_path: `${__dirname}/../data/Docs.json`,
-    cache_path: `${__dirname}/../data/`,
+    docs_versions: {
+        version_1_0_0_0: new DocsTsGeneratorVersion({
+            docs_path: `${__dirname}/../data/1.0/en-US.json`,
+            cache_path: `${__dirname}/../data/1.0/`,
+            UnrealEngineString_quote_mode: 'double',
+        }),
+        update8: new DocsTsGeneratorVersion({
+            docs_path: `${__dirname}/../data/update8/Docs.json`,
+            cache_path: `${__dirname}/../data/update8/`,
+            UnrealEngineString_quote_mode: 'original',
+        }),
+    },
 });
 export const skip_because_docs_dot_json_not_yet_bundled = {
-    skip: existsSync(`${__dirname}/../data/Docs.json`)
+    skip: existsSync(`${__dirname}/../data/update8/Docs.json`)
         ? false
         : 'Docs.json not yet bundled!',
 };