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

package/lib/DocsTsGenerator.js

@@ -12,6 +12,7 @@ import { TypedString, } from './CustomParsingTypes/TypedString';
 import { compile, esmify, } from '@satisfactory-dev/ajv-utilities';
 import { DocsSchemaByVersion, } from './DocsSchema';
 import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export class ValidationError extends Error {
     errors;
@@ -25,6 +26,7 @@ export class ValidationError extends Error {
 export class DocsTsGeneratorVersion {
     docs;
     cache_path;
+    common_types_from_module;
     docs_path;
     types_from_module;
     // eslint-disable-next-line max-len
@@ -33,11 +35,12 @@ export class DocsTsGeneratorVersion {
     // 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, }) {
+    cache_path = undefined, UnrealEngineString_quote_mode, types_from_module = undefined, common_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;
+        this.common_types_from_module = common_types_from_module;
     }
 }
 export class DocsTsGenerator {
@@ -68,12 +71,18 @@ export class DocsTsGenerator {
     async definition(version, $ref) {
         const schema = await this.schema(version);
         if (!property_exists_on_object(schema.$defs, $ref)) {
+            return this.definition_from_common($ref);
+        }
+        return schema.$defs[$ref];
+    }
+    definition_from_common($ref) {
+        if (!property_exists_on_object(common_schema.$defs, $ref)) {
             throw new NoMatchError({
                 $ref,
-                options: Object.keys(schema.$defs),
+                options: Object.keys(common_schema.$defs),
             });
         }
-        return schema.$defs[$ref];
+        return Promise.resolve(common_schema.$defs[$ref]);
     }
     async get(version) {
         return this.validate(version, await this.load(version), await this.schema(version));
@@ -85,9 +94,19 @@ export class DocsTsGenerator {
         else if ('version_1_0_0_0' === version) {
             return this.schema_version_1_0_0_0();
         }
+        else if ('common' === version) {
+            return this.schema_common();
+        }
         throw new Error('Could not find specified schema!');
     }
     // eslint-disable-next-line max-len
+    async schema_common() {
+        const schema = this.schema_data.common.en_US.schema;
+        // eslint-disable-next-line max-len
+        await this.validate_schema('common', schema);
+        return 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
@@ -120,7 +139,9 @@ export class DocsTsGenerator {
                 let maybe_json;
                 try {
                     if (docs.cache_path) {
-                        const utf8_filename = basename(docs.docs_path).replace(/\.json$/, '.utf8.json');
+                        const file_sha512 = createHash('sha512');
+                        file_sha512.update(await readFile(docs.docs_path));
+                        const utf8_filename = basename(docs.docs_path).replace(/\.json$/, `.utf8.${file_sha512.digest('hex')}.json`);
                         const utf8_filepath = `${docs.cache_path}/${utf8_filename}`;
                         if (existsSync(utf8_filepath)) {
                             const file_contents = await readFile(utf8_filepath);
@@ -182,8 +203,10 @@ export class DocsTsGenerator {
         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;
-            if (object_has_only_properties_that_match_predicate($defs, value_is_non_array_object)) {
-                TypedString.instance().configure_ajv($defs, this.ajv);
+            const { $defs: common_$defs, } = common_schema;
+            if (object_has_only_properties_that_match_predicate($defs, value_is_non_array_object)
+                && object_has_only_properties_that_match_predicate(common_$defs, value_is_non_array_object)) {
+                TypedString.instance().configure_ajv($defs, common_$defs, this.ajv);
             }
         }
         if (docs.cache_path) {

package/lib/DocsValidation.js

@@ -1,6 +1,7 @@
 import { _, } from 'ajv/dist/2020';
 import { UnrealEngineString, } from './CustomParsingTypes/UnrealEngineString';
 import { is_string, } from '@satisfactory-dev/predicates.ts';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
 export function string_to_native_type(data, shallow = false) {
     data = data.trim();
     if (/^\(.+\)$/.test(data)) {
@@ -157,6 +158,7 @@ export function configure_ajv(ajv) {
         return;
     }
     already_configured.add(ajv);
+    ajv.addSchema(common_schema);
     UnrealEngineString.configure_ajv(ajv);
     ajv.addKeyword({
         keyword: 'string_starts_with',

package/lib/StringStartsWith.d.ts

@@ -4,6 +4,11 @@ export type StringStartsWith<Prefix extends string, Suffix extends string = stri
     } as T extends string ? `${Prefix}${Suffix}` : never]: string;
 };
 export type local_ref<T extends string> = StringStartsWith<'#/$defs/', T>;
+export type common_ref<T extends string> = StringStartsWith<'common.schema.json#/$defs/', T>;
+export type any_ref<T extends string> = (local_ref<T> | common_ref<T>);
 export declare function local_ref<T extends string = string>(ref_like_string: T): local_ref<T>;
+export declare function common_ref<T extends string = string>(ref_like_string: T): common_ref<T>;
 export declare function is_$ref(maybe: unknown): maybe is (typeof maybe extends string ? local_ref<typeof maybe> : never);
+export declare function is_common_$ref(maybe: unknown): maybe is (typeof maybe extends string ? common_ref<typeof maybe> : never);
 export declare function $ref_in_array(maybe_$ref: unknown, $ref_array: local_ref<string>[]): maybe_$ref is never;
+export declare function common_$ref_in_array(maybe_$ref: unknown, $ref_array: common_ref<string>[]): maybe_$ref is never;

package/lib/StringStartsWith.js

@@ -9,9 +9,24 @@ export function local_ref(ref_like_string) {
     }
     return `#/$defs/${ref_like_string}`;
 }
+export function common_ref(ref_like_string) {
+    if (/\s+/.test(ref_like_string)) {
+        throw new Error('No spacing characters allowed!');
+    }
+    if (ref_like_string.startsWith('common.schema.json#/$defs/')) {
+        throw new NoMatchError(ref_like_string, 'Already a common ref!');
+    }
+    return `common.schema.json#/$defs/${ref_like_string}`;
+}
 export function is_$ref(maybe) {
     return is_string(maybe) && maybe.startsWith('#/$defs/');
 }
+export function is_common_$ref(maybe) {
+    return is_string(maybe) && maybe.startsWith('common.schema.json#/$defs/');
+}
 export function $ref_in_array(maybe_$ref, $ref_array) {
     return is_$ref(maybe_$ref) && $ref_array.includes(maybe_$ref);
 }
+export function common_$ref_in_array(maybe_$ref, $ref_array) {
+    return is_common_$ref(maybe_$ref) && $ref_array.includes(maybe_$ref);
+}

package/lib/TsFactoryWrapper.js

@@ -1,7 +1,8 @@
 import ts from 'typescript';
 import { is_string, non_empty_map, } from '@satisfactory-dev/predicates.ts';
 export function adjust_class_name(class_name) {
-    if ('boolean' === class_name) {
+    if ('boolean' === class_name
+        || 'common_type__boolean' === class_name) {
         return 'Docs_boolean';
     }
     if ('class' === class_name) {

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

@@ -2,10 +2,10 @@ 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_inner_object_type_no_required, typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
-import { local_ref } from '../../StringStartsWith';
+import { common_ref, 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);
+    constructor(supported_refs: local_ref<string>[], supported_common_refs: common_ref<string>[], discovery: TypeDefinitionDiscovery);
     generate(): (raw_data: typed_string_parent_type) => TypeLiteralNode | TupleTypeNode | UnionTypeNode;
     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;

package/lib/TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js

@@ -28,11 +28,11 @@ function create_combinations(values) {
 }
 export class typed_string extends GeneratorDoesDiscovery {
     known_types;
-    constructor(supported_refs, discovery) {
+    constructor(supported_refs, supported_common_refs, discovery) {
         super({
             ...generate_object_parent_schema(),
             $defs: {
-                ...generate_typed_string_$defs(supported_refs),
+                ...generate_typed_string_$defs(supported_refs, supported_common_refs),
             },
         }, discovery);
         this.known_types = [

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

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

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

@@ -3,7 +3,7 @@ import { schema as ObjectTypeSchema, } from '../ObjectType';
 import { adjust_class_name, } from '../../../TsFactoryWrapper';
 import { GeneratorDoesDiscovery, } from '../../GeneratorDoesDiscovery';
 export class ExtendsObject extends GeneratorDoesDiscovery {
-    constructor(supported_refs, discovery) {
+    constructor(supported_refs, common_supported_refs, discovery) {
         const { type, additionalProperties, properties, ...rest } = ObjectTypeSchema;
         super({
             ...rest,
@@ -12,7 +12,10 @@ export class ExtendsObject extends GeneratorDoesDiscovery {
             required: ['$ref'],
             properties: {
                 ...properties,
-                $ref: { type: 'string', enum: supported_refs },
+                $ref: { type: 'string', enum: [
+                        ...supported_refs,
+                        ...common_supported_refs,
+                    ] },
                 unevaluatedProperties: { type: 'boolean', const: false },
             },
         }, discovery);
@@ -34,6 +37,9 @@ export class ExtendsObject extends GeneratorDoesDiscovery {
         };
     }
     create_reference_type($ref) {
-        return ts.factory.createTypeReferenceNode(adjust_class_name(`${$ref.substring(8)}__type`));
+        const ref_substring = $ref.startsWith('common.schema.json#/$defs/')
+            ? `common_type__${$ref.substring(26)}`
+            : $ref.substring(8);
+        return ts.factory.createTypeReferenceNode(adjust_class_name(`${ref_substring}__type`));
     }
 }

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

@@ -24,8 +24,10 @@ export declare const schema: {
     additionalProperties: boolean;
     properties: {
         $ref: {
-            type: string;
-            pattern: string;
+            oneOf: {
+                type: string;
+                pattern: string;
+            }[];
         };
         type: {
             type: string;

package/lib/TypeDefinitionDiscovery/JsonSchema/ObjectType.js

@@ -7,7 +7,12 @@ export const schema = {
     required: ['type', 'properties'],
     additionalProperties: false,
     properties: {
-        $ref: { type: 'string', pattern: '^#/\\$defs/' },
+        $ref: {
+            oneOf: [
+                { type: 'string', pattern: '^#/\\$defs/' },
+                { type: 'string', pattern: '^common\\.schema\\.json#/\\$defs/' },
+            ],
+        },
         type: { type: 'string', const: 'object' },
         additionalProperties: { type: 'boolean', const: false },
         unevaluatedProperties: { type: 'boolean', const: false },
@@ -64,8 +69,11 @@ export class ObjectType extends GeneratorDoesDiscovery {
                 type = type_reference_node('Exclude', type, exclude);
             }
             else if ('$ref' in raw_data && is_string(raw_data.$ref)) {
+                const $ref_substring = raw_data.$ref.startsWith('common.schema.json#/$defs/')
+                    ? `common_type__${raw_data.$ref.substring(26)}`
+                    : raw_data.$ref.substring(8);
                 type = ts.factory.createIntersectionTypeNode([
-                    type_reference_node(adjust_class_name(`${raw_data.$ref.substring(8)}__type`)),
+                    type_reference_node(adjust_class_name(`${$ref_substring}__type`)),
                     type,
                 ]);
             }

package/lib/TypeDefinitionDiscovery.js

@@ -13,16 +13,24 @@ import { adjust_class_name, create_modifiers, } from './TsFactoryWrapper';
 import { reduce, remap, remove_indentation, } from './MarkdownUtilities';
 import { compile, } from '@satisfactory-dev/ajv-utilities';
 import { NoMatchError, } from './Exceptions';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
 function is_schema_with_$defs(schema, discovered_types) {
     return (object_has_property(schema, '$defs', value_is_non_array_object)
-        && Object.keys(schema.$defs).every(maybe => (maybe.startsWith('#/$defs/')
+        && Object.keys(schema.$defs).every(maybe => (maybe.startsWith('common.schema.json#/$defs/')
             ? maybe
-            : `#/$defs/${maybe}`) in discovered_types)
+            : (maybe.startsWith('#/$defs/')
+                ? maybe
+                : `#/$defs/${maybe}`)) in discovered_types)
         && Object.keys(discovered_types).every(maybe => {
+            if (maybe.startsWith('common.schema.json#/$defs/')) {
+                const ref = maybe.substring(26);
+                const common_$defs = common_schema.$defs;
+                return (object_has_property(common_$defs, ref, value_is_non_array_object));
+            }
             const ref = (maybe.startsWith('#/$defs/')
                 ? maybe.substring(8)
                 : maybe);
-            return value_is_non_array_object(schema.$defs[ref]);
+            return value_is_non_array_object(schema.$defs[ref]) || (ref in common_schema.$defs);
         }));
 }
 export class TypeDefinitionDiscovery extends FilesGenerator {
@@ -67,7 +75,9 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         const types = await this.discover_type_$defs();
         for (const entry of Object.entries(types.found_types)) {
             const [definition, generator] = entry;
-            const $ref = definition.substring(8);
+            const $ref = definition.startsWith('common.schema.json#/$defs/')
+                ? definition.substring(26)
+                : definition.substring(8);
             const target_file = guess_filename($ref);
             yield {
                 file: target_file,
@@ -106,11 +116,27 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
             'FGEquipmentDescriptor--base': 'FGEquipment',
         };
         const discovered_types = await this.types_discovery.discover_types();
+        const all_referenced_common_types = [
+            ...discovered_types.discovered_types,
+            ...discovered_types.missed_types,
+        ]
+            .filter(e => e.startsWith('common.schema.json#/$defs/'))
+            .map(e => e.substring(26));
         const all_referenced_types = [
             ...discovered_types.discovered_types,
             ...discovered_types.missed_types,
-        ].map(e => e.substring(8)).sort((a, b) => a.localeCompare(b));
-        const supported_types = discovered_types.discovered_types.map(e => e.substring(8));
+        ].map(e => {
+            if (e.startsWith('common.schema.json#/$defs/')) {
+                return e.substring(26);
+            }
+            return e.substring(8);
+        }).sort((a, b) => a.localeCompare(b));
+        const supported_types = discovered_types.discovered_types.map((e) => {
+            if (e.startsWith('common.schema.json#/$defs/')) {
+                return e.substring(26);
+            }
+            return e.substring(8);
+        });
         for (const item of all_referenced_types) {
             const parts = item.split('--');
             let checking = grouped_progress;
@@ -153,7 +179,9 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
 					${'#'.repeat(group.depth)} ${group.title}
 
 					${group.members.map((key) => {
-                return `-   [${supported_types.includes(key) ? 'x' : ' '}] ${key.replace(/__/g, '\\_\\_')}`;
+                return `-   [${supported_types.includes(key) ? 'x' : ' '}] ${key.replace(/__/g, '\\_\\_')}${all_referenced_common_types.includes(key)
+                    ? ' (common type)'
+                    : ''}`;
             }).join('\n')}`);
         }).join('\n\n')}
 		`);
@@ -162,15 +190,30 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         const result = {
             found_types: {},
             missing_types: [],
+            common_types: [],
             found_classes: [],
             missing_classes: [],
         };
         const $defs = Object.keys(discovered_types);
         for (const definition of $defs) {
-            const $ref = definition.substring(8);
+            const $ref = (definition.startsWith('#/$defs/')
+                ? definition.substring(8)
+                : definition.substring(26));
+            let use_definition = definition;
+            if ('common' === this.version
+                && definition.startsWith('common.schema.json#/$defs/')) {
+                use_definition = definition.substring(18);
+            }
             const generator = this.candidates.find(e => e.check(schema.$defs[$ref]));
             if (generator) {
-                result.found_types[definition] = generator.generate();
+                result.found_types[use_definition] = generator.generate();
+            }
+            else if ('common' !== this.version
+                && ((definition.startsWith('#/$defs/')
+                    && definition.substring(8) in common_schema.$defs)
+                    || (definition.startsWith('common.schema.json#/$defs/')
+                        && definition.substring(26) in common_schema.$defs))) {
+                result.common_types.push(definition);
             }
             else {
                 result.missing_types.push(definition);
@@ -217,7 +260,10 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                         pattern: '^\\/Script\\/CoreUObject\\.Class\'\\/Script\\/FactoryGame\\.',
                     },
                     type: { type: 'string', const: 'object' },
-                    $ref: { type: 'string', const: '#/$defs/NativeClass' },
+                    $ref: { type: 'string', enum: [
+                            '#/$defs/NativeClass',
+                            'common.schema.json#/$defs/NativeClass',
+                        ] },
                     unevaluatedProperties: { type: 'boolean', const: false },
                     properties: {
                         type: 'object',

package/lib/TypeDefinitionWriter.js

@@ -10,7 +10,7 @@ import { glob, } from 'glob';
 import { object_has_property, require_non_empty_array, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import ts from 'typescript';
 import { DocsTsAutoImports, } from './DocsTsAutoImports';
-import { dirname, } from 'node:path';
+import { dirname, relative, } from 'node:path';
 import { eslint_generated_types, format_code, } from './DocsTsGenerator';
 import { UnrealEngineString as legacy_UnrealEngineString_module, } from './CustomParsingTypes/UnrealEngineString';
 import { string_starts_with, StringPassedRegExp, } from './TypesGeneration/validators';
@@ -20,6 +20,8 @@ import { FilesGenerator as DocsFiles, } from './DocsTsGenerator/FilesGenerator';
 import { DataDiscovery, } from './DataDiscovery';
 import { __dirname_from_meta, } from './__dirname';
 import { compile, } from '@satisfactory-dev/ajv-utilities';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
+import { common_ref, } from './StringStartsWith';
 const __dirname = __dirname_from_meta(import.meta);
 export class TypeDefinitionWriter {
     _discovery = undefined;
@@ -85,7 +87,9 @@ export class TypeDefinitionWriter {
             $defs: schema.$defs,
             ...e,
         }));
-        if (!object_has_property(schema.$defs, 'NativeClass', value_is_non_array_object)) {
+        if ('common' === this.version
+            ? !object_has_property(schema.$defs, 'NativeClass', value_is_non_array_object)
+            : !object_has_property(common_schema.$defs, 'NativeClass', value_is_non_array_object)) {
             throw new Error('Could not find NativeClass on provided schema!');
         }
         const files = await FilesGenerator.merge_files([
@@ -100,10 +104,13 @@ export class TypeDefinitionWriter {
         ]);
         performance.measure(`${this.constructor.name}.write() FilesGenerator`, `${this.constructor.name}.write() start`);
         performance.mark(`${this.constructor.name}.write() start`);
-        const auto_imports = new DocsTsAutoImports(files);
+        const auto_imports = new DocsTsAutoImports(files, this.version);
         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.${this.version}.json`, auto_imports.imports_come_from);
+        if ('common' === this.version) {
+            await writeFile(`${__dirname}/../common-imports.json`, auto_imports.non_faux_imports_come_from);
+        }
         const printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,
         });
@@ -206,10 +213,20 @@ export class TypeDefinitionWriter {
             }
             let code = await format_code(node_strings
                 .join('\n\n'));
-            const types_from_module = this.docs.docs_versions[this.version]?.types_from_module;
+            const { types_from_module, common_types_from_module, } = this.docs.docs_versions[this.version] || {
+                types_from_module: undefined,
+                common_types_from_module: undefined,
+            };
             if (types_from_module) {
                 code = code.replace(/} from '(?:\.\.\/)+(classes|common|utils)\//g, `} from '${types_from_module}/$1/`);
             }
+            if (common_types_from_module) {
+                code = code.replace(/} from 'import_from_common;(classes|common|utils)\//g, `} from '${common_types_from_module}/$1/`);
+            }
+            else {
+                code = code.replace(/} from 'import_from_common;(classes|common|utils)\//g, `} from '${relative(dir, dirname(parent_folder))}/common/$1/`);
+            }
+            code = code.replace(/common_type__/g, '');
             await writeFile(file_name, code);
         }
         performance.measure(`${this.constructor.name}.write() actually write files`, `${this.constructor.name}.write() start`);
@@ -224,8 +241,11 @@ export class TypeDefinitionWriter {
         if (!this.prepared) {
             this.prepared = true;
             const discovery = await this.discovery;
-            const discovered_types = (await discovery.types_discovery.discover_types()).discovered_types;
-            discovery.add_candidates(new ObjectType(discovery), new ArrayType(discovered_types, discovery), new ExtendsObject(discovered_types, discovery), new typed_string(discovered_types, discovery), new oneOf_or_anyOf(discovery));
+            const { discovered_types, } = (await discovery.types_discovery.discover_types());
+            if ('common' === this.version) {
+                discovered_types.push(...Object.keys(common_schema.$defs).map((e) => `#/$defs/${e}`).filter(maybe => !discovered_types.includes(maybe)));
+            }
+            discovery.add_candidates(new ObjectType(discovery), new ArrayType(discovered_types, discovery), new ExtendsObject(discovered_types, Object.keys(common_schema.$defs).map(common_ref), discovery), new typed_string(discovered_types, Object.keys(common_schema.$defs).map(common_ref), discovery), new oneOf_or_anyOf(discovery));
         }
     }
     static can_class_have_tree(class_node) {

package/lib/TypesDiscovery/JsonSchema/$ref.d.ts

@@ -5,3 +5,10 @@ export declare class $ref extends CandidatesDiscovery {
     constructor(schema: SchemaObject);
     discovery_candidates(current: unknown, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
 }
+export declare class common_$ref extends CandidatesDiscovery {
+    readonly $defs: {
+        [key: string]: true;
+    };
+    constructor();
+    discovery_candidates(current: unknown, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
+}

package/lib/TypesDiscovery/JsonSchema/$ref.js

@@ -1,5 +1,7 @@
 import { CandidatesDiscovery, } from '../CandidatesDiscovery';
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
+// eslint-disable-next-line max-len
+import common_schema from '../../../schema/common.schema.json' with { type: 'json' };
 export class $ref extends CandidatesDiscovery {
     $defs;
     constructor(schema) {
@@ -29,3 +31,43 @@ export class $ref extends CandidatesDiscovery {
         return undefined;
     }
 }
+export class common_$ref extends CandidatesDiscovery {
+    $defs;
+    constructor() {
+        super(common_schema);
+        this.$defs =
+            object_has_property(common_schema, '$defs', value_is_non_array_object)
+                ? Object.fromEntries(Object.keys(common_schema.$defs).map(e => [e, true]))
+                : {};
+    }
+    discovery_candidates(current, discovered_types) {
+        const $defs = this.$defs;
+        function has_definition_$ref(maybe) {
+            return (object_has_property(maybe, '$ref', is_string)
+                && maybe.$ref.startsWith('#/$defs/')
+                && maybe.$ref.substring(8) in $defs);
+        }
+        function schema_has_definition(maybe, schema) {
+            return (maybe.startsWith('#/$defs/')
+                && maybe.substring(8) in schema.$defs);
+        }
+        function schema_has_definition_from_external(maybe, schema) {
+            return (maybe.startsWith('common.schema.json#/$defs/')
+                && maybe.substring(26) in schema.$defs);
+        }
+        if (has_definition_$ref(current)
+            && schema_has_definition(current.$ref, this.schema)
+            && !discovered_types.has(current.$ref)) {
+            discovered_types.add(current.$ref);
+            return [this.schema.$defs[current.$ref.substring(8)]];
+        }
+        if (value_is_non_array_object(current)
+            && object_has_property(current, '$ref', is_string)
+            && schema_has_definition_from_external(current.$ref, this.schema)
+            && !discovered_types.has(current.$ref)) {
+            discovered_types.add(current.$ref);
+            return [this.schema.$defs[current.$ref.substring(26)]];
+        }
+        return undefined;
+    }
+}

package/lib/TypesDiscovery.js

@@ -1,7 +1,7 @@
 import { object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import { properties, } from './TypesDiscovery/JsonSchema/properties';
 import { non_empty_array_property, } from './TypesDiscovery/non_empty_array_property';
-import { $ref, } from './TypesDiscovery/JsonSchema/$ref';
+import { $ref, common_$ref, } from './TypesDiscovery/JsonSchema/$ref';
 import { non_array_object_property, } from './TypesDiscovery/non_array_object_property';
 import { compile, } from '@satisfactory-dev/ajv-utilities';
 import { local_ref, } from './StringStartsWith';
@@ -9,6 +9,7 @@ import { typed_string, } from './TypesDiscovery/CustomParsingTypes/typed_string'
 import { ConstString, } from './TypesDiscovery/JsonSchema/const';
 import { EnumString, } from './TypesDiscovery/JsonSchema/enum';
 import { UnrealEngineString, } from './TypesDiscovery/CustomParsingTypes/UnrealEngineString';
+import common_schema from '../schema/common.schema.json' with { type: 'json' };
 export class TypesDiscovery {
     discovery;
     candidates_discovery;
@@ -55,12 +56,13 @@ export class TypesDiscovery {
         if (!object_has_property(schema, '$defs', value_is_non_array_object)) {
             throw new Error('Schema appears to have no $defs');
         }
-        if (!object_has_property(schema.$defs, 'NativeClass', value_is_non_array_object)) {
+        const target_schema = 'common' === version ? schema : common_schema;
+        if (!object_has_property(target_schema.$defs, 'NativeClass', value_is_non_array_object)) {
             throw new Error('Could not find NativeClass on provided schema!');
         }
         return compile(docs.ajv, {
-            $defs: schema.$defs,
-            ...schema.$defs.NativeClass,
+            $defs: target_schema.$defs,
+            ...target_schema.$defs.NativeClass,
         });
     }
     static standard_jsonschema_discovery(schema) {
@@ -71,6 +73,7 @@ export class TypesDiscovery {
             new non_array_object_property('items', schema),
             new properties(schema),
             new $ref(schema),
+            new common_$ref(),
             new ConstString(schema),
             new EnumString(schema),
         ];

package/lib/helpers.js

@@ -19,6 +19,11 @@ configure_ajv(ajv);
 export const docs = new DocsTsGenerator({
     ajv,
     docs_versions: {
+        common: new DocsTsGeneratorVersion({
+            docs_path: `${__dirname}/../data/common/faux.json`,
+            cache_path: `${__dirname}/../data/common/`,
+            UnrealEngineString_quote_mode: 'original',
+        }),
         version_1_0_0_0: new DocsTsGeneratorVersion({
             docs_path: `${__dirname}/../data/1.0/en-US.json`,
             cache_path: `${__dirname}/../data/1.0/`,

package/package.json

@@ -38,5 +38,5 @@
     "typescript": "~5.5.2",
     "typescript-eslint": "^8.2.0"
   },
-  "version": "0.11.1"
+  "version": "0.12.0"
 }