@satisfactory-dev/docs.json.ts 0.11.0 → 0.12.0

package/lib/DataDiscovery/JsonSchema/Object.js

@@ -57,6 +57,17 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
                 }
             }
         }
+        else if ('$ref' in schema
+            && is_string(schema.$ref)
+            && schema.$ref.startsWith('common.schema.json#/$defs/')) {
+            const $ref_converters = Object.entries(await this.resolve_converters_for_common_$ref(schema.$ref));
+            for (const entry of $ref_converters) {
+                const [property, converter] = entry;
+                if (!(property in converters)) {
+                    converters[property] = converter;
+                }
+            }
+        }
         performance.measure(`${this.constructor.name}.resolve_converters() resolve_converters`, `${this.constructor.name}.resolve_converters() start`);
         return converters;
     }
@@ -64,7 +75,11 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         const definition = await this.discovery.docs.definition(this.discovery.version, $ref.substring(8));
         return this.resolve_converters(definition);
     }
-    async resolve_schema(schema, depth = 0) {
+    async resolve_converters_for_common_$ref($ref) {
+        const definition = await this.discovery.docs.definition_from_common($ref.substring(26));
+        return this.resolve_converters(definition);
+    }
+    async resolve_schema(schema, depth = 0, is_common = false) {
         performance.mark(`${this.constructor.name}.resolve_schema() start`);
         const json_string = JSON.stringify(schema);
         if (json_string in this.already_resolved) {
@@ -85,7 +100,17 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         if ('$ref' in schema
             && is_string(schema.$ref)
             && schema.$ref.startsWith('#/$defs/')) {
-            for (const entry of Object.entries(await this.resolve_schema(await this.discovery.docs.definition(this.discovery.version, schema.$ref.substring(8)), depth + 1))) {
+            for (const entry of Object.entries(await this.resolve_schema(await this.discovery.docs.definition(is_common ? 'common' : this.discovery.version, schema.$ref.substring(8)), depth + 1, is_common))) {
+                const [property, sub_schema] = entry;
+                if (!(property in resolved_schema)) {
+                    resolved_schema[property] = sub_schema;
+                }
+            }
+        }
+        else if ('$ref' in schema
+            && is_string(schema.$ref)
+            && schema.$ref.startsWith('common.schema.json#/$defs/')) {
+            for (const entry of Object.entries(await this.resolve_schema(await this.discovery.docs.definition_from_common(schema.$ref.substring(26)), depth + 1, true))) {
                 const [property, sub_schema] = entry;
                 if (!(property in resolved_schema)) {
                     resolved_schema[property] = sub_schema;
@@ -105,7 +130,10 @@ export class ObjectConverter extends ObjectConverterMatchesSchema {
             additionalProperties: false,
             properties: {
                 type: { type: 'string', const: 'object' },
-                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+                $ref: {
+                    type: 'string',
+                    pattern: '^(common.schema.json)?#/\\$defs/',
+                },
                 required: {
                     type: 'array',
                     minItems: 1,
@@ -158,7 +186,10 @@ export class PatternedObjectConverter extends ObjectConverterMatchesSchema {
             additionalProperties: false,
             properties: {
                 type: { type: 'string', const: 'object' },
-                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+                $ref: {
+                    type: 'string',
+                    pattern: '^(common.schema.json)#/\\$defs/',
+                },
                 additionalProperties: { type: 'boolean', const: false },
                 unevaluatedProperties: { type: 'boolean', const: false },
                 minProperties: { type: 'number', minimum: 1 },

package/lib/DataDiscovery/JsonSchema/OneOf.js

@@ -42,6 +42,9 @@ export class OneOfConverter extends ConverterMatchesSchema {
                     if (err instanceof NoMatchError) {
                         failures.push(err);
                     }
+                    else {
+                        throw err;
+                    }
                 }
             }
         }

package/lib/DataDiscovery/JsonSchema/Ref.js

@@ -9,7 +9,8 @@ export class Ref extends ConverterMatchesSchema {
             required: ['$ref'],
             additionalProperties: false,
             properties: {
-                $ref: { type: 'string', pattern: '^#/\\$defs/' },
+                // eslint-disable-next-line max-len
+                $ref: { type: 'string', pattern: '^(common.schema.json)?#/\\$defs/' },
             },
         });
         this.discovery = discovery;
@@ -43,9 +44,16 @@ export class Ref extends ConverterMatchesSchema {
     async resolve_to_final_converter_schema_only(schema) {
         let checking = schema;
         performance.mark(`${this.constructor.name}.resolve_to_final_converter_schema_only() start`);
+        let version = this.discovery.version;
         if (!(schema.$ref in this.cache)) {
             while (this.can_convert_schema(checking)) {
-                checking = await this.discovery.docs.definition(this.discovery.version, checking.$ref.substring(8));
+                if (checking.$ref.startsWith('common.schema.json#/$defs/')) {
+                    version = 'common';
+                    checking = await this.discovery.docs.definition(version, checking.$ref.substring(26));
+                }
+                else {
+                    checking = await this.discovery.docs.definition(version, checking.$ref.substring(8));
+                }
             }
             if (this.can_convert_schema(checking)) {
                 throw new NoMatchError({

package/lib/DataDiscovery.js

@@ -15,6 +15,7 @@ import { OneOfConverter, } from './DataDiscovery/JsonSchema/OneOf';
 import { StringStartsWithConverter, } from './DataDiscovery/CustomTypes/StringStartsWith';
 import { UnrealEngineStringConverter, } from './DataDiscovery/CustomTypes/UnrealEngineString';
 import { Ref, } from './DataDiscovery/JsonSchema/Ref';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
 export class DataDiscovery extends FilesGenerator {
     progress = {};
     candidates;
@@ -26,6 +27,7 @@ export class DataDiscovery extends FilesGenerator {
         this.docs = docs;
         this.literal = literal || new Literal();
         this.version = version;
+        const { $defs: common_$defs, } = common_schema;
         this.candidates = docs.schema(version).then(({ $defs }) => {
             return [
                 new BooleanConverter(docs.ajv),
@@ -38,7 +40,7 @@ export class DataDiscovery extends FilesGenerator {
                 new UnrealEngineStringConverter(),
                 new ObjectConverter(this),
                 new PatternedObjectConverter(this),
-                new TypedStringConverter(this, $defs),
+                new TypedStringConverter(this, $defs, common_$defs),
                 new OneOfConverter(this),
                 new Ref(this),
             ];
@@ -54,6 +56,13 @@ export class DataDiscovery extends FilesGenerator {
             this.docs.schema(this.version),
             this.docs.get(this.version),
         ]);
+        if ('common' === this.version) {
+            return result;
+        }
+        else if (!('prefixItems' in schema)
+            || !Array.isArray(schema.prefixItems)) {
+            throw new Error(`Unsupported schema!`);
+        }
         let index = 0;
         for (const e of docs) {
             performance.mark(`${this.constructor.name}.generate() start`);

package/lib/DocsSchema.d.ts

@@ -1,5 +1,6 @@
 import version_1_0_0_0_schema from '../schema/1.0.schema.json';
 import update8_schema from '../schema/update8.schema.json';
+import common_schema from '../schema/common.schema.json';
 export declare class DocsSchema<schema> {
     readonly schema: schema;
     constructor({ schema, }: {
@@ -13,6 +14,7 @@ declare class DocsSchemaByLanguageCode<en_US> {
     });
 }
 export declare class DocsSchemaByVersion {
+    readonly common: DocsSchemaByLanguageCode<typeof common_schema>;
     readonly update8: DocsSchemaByLanguageCode<typeof update8_schema>;
     readonly version_1_0_0_0: DocsSchemaByLanguageCode<typeof version_1_0_0_0_schema>;
     constructor();

package/lib/DocsSchema.js

@@ -4,6 +4,9 @@ import version_1_0_0_0_schema from '../schema/1.0.schema.json' with {
 import update8_schema from '../schema/update8.schema.json' with {
     type: 'json'
 };
+import common_schema from '../schema/common.schema.json' with {
+    type: 'json'
+};
 export class DocsSchema {
     schema;
     constructor({ schema, }) {
@@ -17,9 +20,13 @@ class DocsSchemaByLanguageCode {
     }
 }
 export class DocsSchemaByVersion {
+    common;
     update8;
     version_1_0_0_0;
     constructor() {
+        this.common = new DocsSchemaByLanguageCode({
+            en_US: common_schema,
+        });
         this.version_1_0_0_0 = new DocsSchemaByLanguageCode({
             en_US: version_1_0_0_0_schema,
         });

package/lib/DocsToAutoImport/from_Node_array.js

@@ -228,17 +228,17 @@ export function EntityName_array_from_Node_array(nodes) {
     ];
 }
 export function from_Node_array(nodes) {
-    return [
-        ...EntityName_array_from_Node_array(nodes).map((checking) => {
-            let recursion_iteration = 0;
-            while (ts.isQualifiedName(checking)) {
-                if (recursion_iteration > recursion_limit) {
-                    throw new Error('Recursion limit exceeded!');
+    return [...(new Set([
+            ...EntityName_array_from_Node_array(nodes).map((checking) => {
+                let recursion_iteration = 0;
+                while (ts.isQualifiedName(checking)) {
+                    if (recursion_iteration > recursion_limit) {
+                        throw new Error('Recursion limit exceeded!');
+                    }
+                    checking = checking.left;
+                    ++recursion_iteration;
                 }
-                checking = checking.left;
-                ++recursion_iteration;
-            }
-            return checking.escapedText.toString();
-        }),
-    ];
+                return checking.escapedText.toString();
+            }),
+        ])).values()];
 }

package/lib/DocsTsAutoImports.d.ts

@@ -1,12 +1,15 @@
 import ts from 'typescript';
 import { ImportTracker } from './TypesGeneration';
+import { docs_versions } from './DocsTsGenerator';
 export declare class DocsTsAutoImports {
     private readonly comes_from;
     private readonly files_entries;
+    private readonly version;
     constructor(files: {
         [key: string]: ts.Node[];
-    });
+    }, version: keyof docs_versions);
     get imports_come_from(): string;
+    get non_faux_imports_come_from(): string;
     generate(): ImportTracker;
     protected file_exports(): {
         [key: string]: [string, ...string[]];

package/lib/DocsTsAutoImports.js

@@ -3,24 +3,42 @@ import { ImportTracker, } from './TypesGeneration';
 import { basename, dirname, relative, } from 'node:path';
 import { from_Node_array, } from './DocsToAutoImport/from_Node_array';
 import { NoMatchError, } from './Exceptions';
+import common_types_map from '../common-imports.json' with { type: 'json' };
 export class DocsTsAutoImports {
     comes_from = {};
     files_entries;
-    constructor(files) {
+    version;
+    constructor(files, version) {
         this.files_entries = Object.entries(files);
+        this.version = version;
     }
     get imports_come_from() {
         return `${JSON.stringify(this.comes_from, null, '\t')}\n`;
     }
+    get non_faux_imports_come_from() {
+        return `${JSON.stringify(Object.fromEntries(Object.entries(this.comes_from)
+            .filter(maybe => !/(faux|common_type)/i.test(maybe[0]))
+            .map(e => [
+            `common_type__${e[0]}`,
+            e[1],
+        ])), null, '\t')}\n`;
+    }
     generate() {
         const file_exports = this.file_exports();
         for (const entry of Object.entries(file_exports)) {
             const [filename, exports_these] = entry;
             for (const export_name of exports_these) {
-                if (export_name in this.comes_from) {
-                    throw new NoMatchError(entry, `${export_name} conflict!`);
+                const export_filename = filename.replace(/\.ts$/, '');
+                if (export_name in this.comes_from
+                    && export_filename !== this.comes_from[export_name]) {
+                    throw new NoMatchError({
+                        export_name,
+                        export_filename,
+                        export_filename_conflict: this.comes_from[export_name],
+                        entry,
+                    }, `${export_name} conflict!`);
                 }
-                this.comes_from[export_name] = filename.replace(/\.ts$/, '');
+                this.comes_from[export_name] = export_filename;
             }
         }
         const auto_imports = {};
@@ -31,11 +49,20 @@ export class DocsTsAutoImports {
                 .filter((maybe) => maybe in this.comes_from)
                 .filter((maybe) => filename.replace(/\.ts$/, '') !==
                 this.comes_from[maybe]);
+            const common_reference_names = [
+                ...node_names,
+            ].filter((maybe) => maybe in common_types_map);
+            if (common_reference_names.length && this.version === 'common') {
+                reference_names.push(...common_reference_names.map(e => e.substring(13)).filter(maybe => !reference_names.includes(maybe)));
+            }
             if (reference_names.length) {
                 if (!(filename in auto_imports)) {
                     auto_imports[filename] = {};
                 }
                 for (const import_this of reference_names) {
+                    if (`${this.comes_from[import_this]}.ts` === filename) {
+                        continue;
+                    }
                     let import_from = `${relative(dirname(filename), dirname(this.comes_from[import_this]))}/${basename(this.comes_from[import_this])}`;
                     if (import_from.startsWith('/')) {
                         import_from = `.${import_from}`;
@@ -51,6 +78,20 @@ export class DocsTsAutoImports {
                     }
                 }
             }
+            if (common_reference_names.length && 'common' !== this.version) {
+                if (!(filename in auto_imports)) {
+                    auto_imports[filename] = {};
+                }
+                for (const import_this of common_reference_names) {
+                    const import_from = `import_from_common;${common_types_map[import_this]}`;
+                    if (!(import_from in auto_imports[filename])) {
+                        auto_imports[filename][import_from] = [];
+                    }
+                    if (!auto_imports[filename][import_from].includes(import_this)) {
+                        auto_imports[filename][import_from].push(import_this);
+                    }
+                }
+            }
         }
         const import_tracker = new ImportTracker();
         import_tracker.merge_and_set_imports(auto_imports);