@satisfactory-dev/docs.json.ts 0.16.1 → 0.17.1

package/lib/TypeDefinitionDiscovery.js

@@ -1,27 +1,27 @@
-import { TypesDiscovery, } from './TypesDiscovery';
+import { TypesDiscovery, } from "./TypesDiscovery.js";
 import { is_non_empty_array, is_string, object_has_non_empty_array_property, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 import ts from 'typescript';
-import { Const, } from './TypeDefinitionDiscovery/JsonSchema/String/Const';
-import { Pattern, } from './TypeDefinitionDiscovery/JsonSchema/String/Pattern';
-import { Enum, } from './TypeDefinitionDiscovery/JsonSchema/String/Enum';
-import { BooleanEnum, } from './TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum';
-import { string_starts_with, } from './TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
-import { UnrealEngineString, } from './TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString';
-import { NonEmptyString, NonEmptyStringWithExclusions, StringType, } from './TypeDefinitionDiscovery/JsonSchema/String';
-import { FilesGenerator, guess_filename, } from './FilesGenerator';
-import { adjust_class_name, create_modifiers, } from './TsFactoryWrapper';
-import { reduce, remap, remove_indentation, } from './MarkdownUtilities';
+import { Const, } from "./TypeDefinitionDiscovery/JsonSchema/String/Const.js";
+import { Pattern, } from "./TypeDefinitionDiscovery/JsonSchema/String/Pattern.js";
+import { Enum, } from "./TypeDefinitionDiscovery/JsonSchema/String/Enum.js";
+import { BooleanEnum, } from "./TypeDefinitionDiscovery/JsonSchema/String/Enum/BooleanEnum.js";
+import { string_starts_with, } from "./TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.js";
+import { UnrealEngineString, } from "./TypeDefinitionDiscovery/CustomParsingTypes/UnrealEngineString.js";
+import { NonEmptyString, NonEmptyStringWithExclusions, StringType, } from "./TypeDefinitionDiscovery/JsonSchema/String.js";
+import { FilesGenerator, guess_filename, } from "./FilesGenerator.js";
+import { adjust_class_name, create_modifiers, } from "./TsFactoryWrapper.js";
+import { reduce, remap, remove_indentation, } from "./MarkdownUtilities.js";
 import { compile, } from '@satisfactory-dev/ajv-utilities';
-import { NoMatchError, } from './Exceptions';
+import { NoMatchError, } from "./Exceptions.js";
 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('common.schema.json#/$defs/')
+        && Object.keys(schema.$defs).every((maybe) => (maybe.startsWith('common.schema.json#/$defs/')
             ? maybe
             : (maybe.startsWith('#/$defs/')
                 ? maybe
                 : `#/$defs/${maybe}`)) in discovered_types)
-        && Object.keys(discovered_types).every(maybe => {
+        && Object.keys(discovered_types).every((maybe) => {
             if (maybe.startsWith('common.schema.json#/$defs/')) {
                 const ref = maybe.substring(26);
                 const common_$defs = common_schema.$defs;
@@ -51,6 +51,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
     }
     async discover_type_$defs() {
         if (!this.$ref_discovery) {
+            // eslint-disable-next-line @stylistic/max-len
             const discovered_types = await this.types_discovery.discover_types();
             if (discovered_types.missed_types.length > 0) {
                 throw new NoMatchError({
@@ -61,7 +62,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
             else if (!is_non_empty_array(discovered_types.discovered_types, is_string)) {
                 throw new Error('No types discovered!');
             }
-            const discovered_types_as_object = Object.fromEntries(discovered_types.discovered_types.map(e => [e, true]));
+            const discovered_types_as_object = Object.fromEntries(discovered_types.discovered_types.map((e) => [e, true]));
             const schema = await this.schema_from_json(discovered_types_as_object);
             this.$ref_discovery = Promise.resolve(this.discover_type_definitions_from(schema, discovered_types_as_object));
         }
@@ -123,12 +124,12 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
             ...discovered_types.discovered_types,
             ...discovered_types.missed_types,
         ]
-            .filter(e => e.startsWith('common.schema.json#/$defs/'))
-            .map(e => e.substring(26));
+            .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 => {
+        ].map((e) => {
             if (e.startsWith('common.schema.json#/$defs/')) {
                 return e.substring(26);
             }
@@ -173,16 +174,18 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
         return remove_indentation(`
 			# Types Progress
 
-			${((supported_types.length /
-            all_referenced_types.length) *
-            100).toFixed(2)}% Complete (${supported_types.length} of ${all_referenced_types.length})
+			${((supported_types.length
+            / all_referenced_types.length)
+            * 100).toFixed(2)}% Complete (${supported_types.length} of ${all_referenced_types.length})
 
 			${reduce(grouped_progress).map((group) => {
             return remove_indentation(`
 					${'#'.repeat(group.depth)} ${group.title}
 
 					${group.members.map((key) => {
-                return `-   [${supported_types.includes(key) ? 'x' : ' '}] ${key.replace(/__/g, '\\_\\_')}${all_referenced_common_types.includes(key)
+                return `-   [${supported_types.includes(key)
+                    ? 'x'
+                    : ' '}] ${key.replace(/__/g, '\\_\\_')}${all_referenced_common_types.includes(key)
                     ? ' (common type)'
                     : ''}`;
             }).join('\n')}`);
@@ -207,7 +210,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                 && definition.startsWith('common.schema.json#/$defs/')) {
                 use_definition = definition.substring(18);
             }
-            const generator = this.candidates.find(e => e.check(schema.$defs[$ref]));
+            const generator = this.candidates.find((e) => e.check(schema.$defs[$ref]));
             if (generator) {
                 result.found_types[use_definition] = generator.generate();
             }
@@ -259,7 +262,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
                 properties: {
                     $comment: {
                         type: 'string',
-                        // eslint-disable-next-line max-len
+                        // eslint-disable-next-line @stylistic/max-len
                         pattern: '^\\/Script\\/CoreUObject\\.Class\'\\/Script\\/FactoryGame\\.',
                     },
                     type: { type: 'string', const: 'object' },
@@ -443,7 +446,7 @@ export class TypeDefinitionDiscovery extends FilesGenerator {
     }
     search(maybe) {
         performance.mark(`${this.constructor.name}.search() start`);
-        const generator = this.candidates.find(e => e.check(maybe));
+        const generator = this.candidates.find((e) => e.check(maybe));
         if (generator) {
             const result = generator.generate()(maybe);
             performance.measure(`${this.constructor.name}.search()`, `${this.constructor.name}.search() start`);

package/lib/TypeDefinitionWriter.d.ts

@@ -1,6 +1,7 @@
-import { TypeDefinitionDiscovery } from './TypeDefinitionDiscovery';
-import ts, { ClassDeclaration } from 'typescript';
-import { docs_versions, DocsTsGenerator } from './DocsTsGenerator';
+import { TypeDefinitionDiscovery } from './TypeDefinitionDiscovery.ts';
+import type { ClassDeclaration } from 'typescript';
+import ts from 'typescript';
+import type { docs_versions, DocsTsGenerator } from './DocsTsGenerator.ts';
 type class_can_have_tree = ClassDeclaration & {
     heritageClauses: [{
         types: [{

package/lib/TypeDefinitionWriter.js

@@ -1,29 +1,27 @@
-import { TypesDiscovery, } from './TypesDiscovery';
-import { TypeDefinitionDiscovery, } from './TypeDefinitionDiscovery';
+import { TypesDiscovery, } from "./TypesDiscovery.js";
+import { TypeDefinitionDiscovery, } from "./TypeDefinitionDiscovery.js";
 import { mkdir, unlink, writeFile, } from 'node:fs/promises';
-import { ObjectType, } from './TypeDefinitionDiscovery/JsonSchema/ObjectType';
-import { ArrayType, } from './TypeDefinitionDiscovery/JsonSchema/ArrayType';
-import { ExtendsObject, } from './TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject';
-import { typed_string, } from './TypeDefinitionDiscovery/CustomParsingTypes/typed_string';
-import { allOf, } from './TypeDefinitionDiscovery/JsonSchema/allOf';
-import { oneOf_or_anyOf, } from './TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf';
+import { ObjectType, } from "./TypeDefinitionDiscovery/JsonSchema/ObjectType.js";
+import { ArrayType, } from "./TypeDefinitionDiscovery/JsonSchema/ArrayType.js";
+import { ExtendsObject, } from "./TypeDefinitionDiscovery/JsonSchema/Object/ExtendsObject.js";
+import { typed_string, } from "./TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js";
+import { allOf, } from "./TypeDefinitionDiscovery/JsonSchema/allOf.js";
+import { oneOf_or_anyOf, } from "./TypeDefinitionDiscovery/JsonSchema/oneOf_or_anyOf.js";
 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 { DocsTsAutoImports, } from "./DocsTsAutoImports.js";
 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';
-import { NoMatchError, } from './Exceptions';
-import { FilesGenerator, FromArray, } from './FilesGenerator';
-import { FilesGenerator as DocsFiles, } from './DocsTsGenerator/FilesGenerator';
-import { DataDiscovery, } from './DataDiscovery';
-import { __dirname_from_meta, } from './__dirname';
+import { eslint_generated_types, format_code, } from "./DocsTsGenerator.js";
+import { UnrealEngineString as legacy_UnrealEngineString_module, } from "./CustomParsingTypes/UnrealEngineString.js";
+import { string_starts_with, StringPassedRegExp, } from "./TypesGeneration/validators.js";
+import { NoMatchError, } from "./Exceptions.js";
+import { FilesGenerator, FromArray, } from "./FilesGenerator.js";
+import { FilesGenerator as DocsFiles, } from "./DocsTsGenerator/FilesGenerator.js";
+import { DataDiscovery, } from "./DataDiscovery.js";
 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);
+import { common_ref, } from "./StringStartsWith.js";
 export class TypeDefinitionWriter {
     _discovery = undefined;
     prepared = false;
@@ -59,8 +57,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--${this.version}.md`, await discovery.generate_markdown());
-        await writeFile(`${__dirname}/../data-progress--${this.version}.md`, await this.data_discovery.generate_markdown());
+        await writeFile(`${import.meta.dirname}/../types-progress--${this.version}.md`, await discovery.generate_markdown());
+        await writeFile(`${import.meta.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`);
@@ -84,7 +82,7 @@ export class TypeDefinitionWriter {
         if (!object_has_property(schema, '$defs', value_is_non_array_object)) {
             throw new Error('Schema appears to have no $defs');
         }
-        const validations = types.found_classes.map(e => compile(this.docs.ajv, {
+        const validations = types.found_classes.map((e) => compile(this.docs.ajv, {
             $defs: schema.$defs,
             ...e,
         }));
@@ -108,9 +106,9 @@ export class TypeDefinitionWriter {
         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);
+        await writeFile(`${import.meta.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);
+            await writeFile(`${import.meta.dirname}/../common-imports.json`, auto_imports.non_faux_imports_come_from);
         }
         const printer = ts.createPrinter({
             newLine: ts.NewLineKind.LineFeed,
@@ -121,7 +119,7 @@ export class TypeDefinitionWriter {
             const classes = entry[1].filter(ts.isClassDeclaration);
             const classes_mapped = Object.fromEntries(classes.map((e) => [e.name?.escapedText + '', e]));
             const class_can_have_trees = Object.fromEntries(classes
-                .filter(maybe => TypeDefinitionWriter.can_class_have_tree(maybe))
+                .filter((maybe) => TypeDefinitionWriter.can_class_have_tree(maybe))
                 .map((e) => [e.name?.escapedText + '', e]));
             const class_parents = Object.values(class_can_have_trees).map((class_node) => {
                 let checking = class_node;
@@ -133,8 +131,7 @@ export class TypeDefinitionWriter {
                         .types[0]
                         ?.expression
                         .escapedText
-                        .toString()) in
-                        class_can_have_trees) {
+                        .toString()) in class_can_have_trees) {
                     const parent_class_name = checking
                         .heritageClauses[0]
                         .types[0]
@@ -174,8 +171,8 @@ export class TypeDefinitionWriter {
                 ];
             }));
             const classes_in_order = class_parent_classes.sort((a, b) => {
-                return (class_parent_class_max_depth[b] -
-                    class_parent_class_max_depth[a]);
+                return (class_parent_class_max_depth[b]
+                    - class_parent_class_max_depth[a]);
             });
             const nodes = [
                 ...import_tracker.generate_imports(entry[0]),
@@ -185,8 +182,7 @@ export class TypeDefinitionWriter {
                         return -1;
                     }
                     if (ts.isClassDeclaration(a) && ts.isClassDeclaration(b)) {
-                        return (classes_in_order.indexOf(a.name?.escapedText + '') -
-                            classes_in_order.indexOf(b.name?.escapedText + ''));
+                        return (classes_in_order.indexOf(a.name?.escapedText + '') - classes_in_order.indexOf(b.name?.escapedText + ''));
                     }
                     return 0;
                 }),
@@ -205,10 +201,12 @@ export class TypeDefinitionWriter {
                     throw new NoMatchError({
                         file_name,
                         node,
-                        err: (err instanceof Error) ? {
-                            message: err.message,
-                            stack: err.stack,
-                        } : err,
+                        err: (err instanceof Error)
+                            ? {
+                                message: err.message,
+                                stack: err.stack,
+                            }
+                            : err,
                     }, 'Error printing node!');
                 }
             }
@@ -232,7 +230,7 @@ export class TypeDefinitionWriter {
         }
         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--${this.version}.md`, await this.data_discovery.generate_markdown());
+        await writeFile(`${import.meta.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);
@@ -244,7 +242,7 @@ export class TypeDefinitionWriter {
             const discovery = await this.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)));
+                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), new allOf(discovery));
         }

package/lib/TypesDiscovery/CandidatesDiscovery.d.ts

@@ -1,4 +1,4 @@
-import { SchemaObject } from 'ajv/dist/2020';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare abstract class CandidatesDiscovery {
     protected readonly schema: SchemaObject;
     constructor(schema: SchemaObject);

package/lib/TypesDiscovery/CustomParsingTypes/UnrealEngineString.d.ts

@@ -1,5 +1,5 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class UnrealEngineString extends CandidatesDiscovery {
     discovery_candidates(current: SchemaObject, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
 }

package/lib/TypesDiscovery/CustomParsingTypes/UnrealEngineString.js

@@ -1,7 +1,7 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { local_ref, } from '../../StringStartsWith';
-import { is_UnrealEngineString_parent, } from '../../CustomParsingTypes/UnrealEngineString';
+import { local_ref, } from "../../StringStartsWith.js";
+import { is_UnrealEngineString_parent, } from "../../CustomParsingTypes/UnrealEngineString.js";
 export class UnrealEngineString extends CandidatesDiscovery {
     discovery_candidates(current, discovered_types) {
         if (object_has_property(current, '$defs', value_is_non_array_object)) {

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

@@ -1,5 +1,5 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class typed_string extends CandidatesDiscovery {
     discovery_candidates(current: SchemaObject, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
     private is_typed_string;

package/lib/TypesDiscovery/CustomParsingTypes/typed_string.js

@@ -1,6 +1,6 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { is_string, object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { local_ref, } from '../../StringStartsWith';
+import { local_ref, } from "../../StringStartsWith.js";
 export class typed_string extends CandidatesDiscovery {
     discovery_candidates(current, discovered_types) {
         if (object_has_property(current, '$defs', value_is_non_array_object)) {

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

@@ -1,5 +1,5 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class $ref extends CandidatesDiscovery {
     private readonly $defs;
     constructor(schema: SchemaObject);

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

@@ -1,15 +1,14 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-// eslint-disable-next-line max-len
+// eslint-disable-next-line @stylistic/max-len
 import common_schema from '../../../schema/common.schema.json' with { type: 'json' };
 export class $ref extends CandidatesDiscovery {
     $defs;
     constructor(schema) {
         super(schema);
-        this.$defs =
-            object_has_property(schema, '$defs', value_is_non_array_object)
-                ? Object.fromEntries(Object.keys(schema.$defs).map(e => [e, true]))
-                : {};
+        this.$defs = (object_has_property(schema, '$defs', value_is_non_array_object)
+            ? Object.fromEntries(Object.keys(schema.$defs).map((e) => [e, true]))
+            : {});
     }
     discovery_candidates(current, discovered_types) {
         const $defs = this.$defs;
@@ -26,7 +25,9 @@ export class $ref extends CandidatesDiscovery {
             && 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)]];
+            return [
+                this.schema.$defs[current.$ref.substring(8)],
+            ];
         }
         return undefined;
     }
@@ -35,10 +36,9 @@ 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]))
-                : {};
+        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;

package/lib/TypesDiscovery/JsonSchema/const.d.ts

@@ -1,5 +1,5 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class ConstString extends CandidatesDiscovery {
     discovery_candidates(current: SchemaObject, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
     private is_const_string;

package/lib/TypesDiscovery/JsonSchema/const.js

@@ -1,6 +1,6 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { is_string, object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { local_ref, } from '../../StringStartsWith';
+import { local_ref, } from "../../StringStartsWith.js";
 export class ConstString extends CandidatesDiscovery {
     discovery_candidates(current, discovered_types) {
         if (object_has_property(current, '$defs', value_is_non_array_object)) {

package/lib/TypesDiscovery/JsonSchema/enum.d.ts

@@ -1,5 +1,5 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class EnumString extends CandidatesDiscovery {
     discovery_candidates(current: SchemaObject, discovered_types: Set<string>): [unknown, ...unknown[]] | undefined;
     private is_enum_string;

package/lib/TypesDiscovery/JsonSchema/enum.js

@@ -1,6 +1,6 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { is_string, object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { local_ref, } from '../../StringStartsWith';
+import { local_ref, } from "../../StringStartsWith.js";
 export class EnumString extends CandidatesDiscovery {
     discovery_candidates(current, discovered_types) {
         if (object_has_property(current, '$defs', value_is_non_array_object)) {

package/lib/TypesDiscovery/JsonSchema/properties.d.ts

@@ -1,4 +1,4 @@
-import { CandidatesDiscovery } from '../CandidatesDiscovery';
+import { CandidatesDiscovery } from '../CandidatesDiscovery.ts';
 export declare class properties extends CandidatesDiscovery {
     discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
 }

package/lib/TypesDiscovery/JsonSchema/properties.js

@@ -1,4 +1,4 @@
-import { CandidatesDiscovery, } from '../CandidatesDiscovery';
+import { CandidatesDiscovery, } from "../CandidatesDiscovery.js";
 import { is_non_empty_array, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 export class properties extends CandidatesDiscovery {
     discovery_candidates(current) {

package/lib/TypesDiscovery/non_array_object_property.d.ts

@@ -1,4 +1,4 @@
-import { PropertyDependentDiscovery } from './CandidatesDiscovery';
+import { PropertyDependentDiscovery } from './CandidatesDiscovery.ts';
 export declare class non_array_object_property extends PropertyDependentDiscovery {
     discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
 }

package/lib/TypesDiscovery/non_array_object_property.js

@@ -1,4 +1,4 @@
-import { PropertyDependentDiscovery, } from './CandidatesDiscovery';
+import { PropertyDependentDiscovery, } from "./CandidatesDiscovery.js";
 import { object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 export class non_array_object_property extends PropertyDependentDiscovery {
     discovery_candidates(current) {

package/lib/TypesDiscovery/non_empty_array_property.d.ts

@@ -1,4 +1,4 @@
-import { PropertyDependentDiscovery } from './CandidatesDiscovery';
+import { PropertyDependentDiscovery } from './CandidatesDiscovery.ts';
 export declare class non_empty_array_property extends PropertyDependentDiscovery {
     discovery_candidates(current: unknown): [unknown, ...unknown[]] | undefined;
 }

package/lib/TypesDiscovery/non_empty_array_property.js

@@ -1,4 +1,4 @@
-import { PropertyDependentDiscovery, } from './CandidatesDiscovery';
+import { PropertyDependentDiscovery, } from "./CandidatesDiscovery.js";
 import { object_has_non_empty_array_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
 export class non_empty_array_property extends PropertyDependentDiscovery {
     discovery_candidates(current) {

package/lib/TypesDiscovery.d.ts

@@ -1,7 +1,8 @@
-import { SchemaObject } from 'ajv/dist/2020';
-import { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery';
-import { docs_versions, DocsDataItem, DocsTsGenerator } from './DocsTsGenerator';
-import { local_ref } from './StringStartsWith';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { CandidatesDiscovery } from './TypesDiscovery/CandidatesDiscovery.ts';
+import type { docs_versions, DocsDataItem } from './DocsTsGenerator.ts';
+import type { DocsTsGenerator } from './DocsTsGenerator.ts';
+import { local_ref } from './StringStartsWith.ts';
 export declare class TypesDiscovery {
     private discovery;
     private readonly candidates_discovery;
@@ -18,7 +19,7 @@ export declare class TypesDiscovery {
         CandidatesDiscovery,
         ...CandidatesDiscovery[]
     ]);
-    static generate_is_NativeClass(docs: DocsTsGenerator, version: keyof docs_versions): Promise<import("ajv/dist/types").ValidateFunction<DocsDataItem>>;
+    static generate_is_NativeClass(docs: DocsTsGenerator, version: keyof docs_versions): Promise<import("ajv").ValidateFunction<DocsDataItem>>;
     static standard_jsonschema_discovery(schema: SchemaObject): ([
         CandidatesDiscovery,
         ...CandidatesDiscovery[]

package/lib/TypesDiscovery.js

@@ -1,14 +1,14 @@
 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, common_$ref, } from './TypesDiscovery/JsonSchema/$ref';
-import { non_array_object_property, } from './TypesDiscovery/non_array_object_property';
+import { properties, } from "./TypesDiscovery/JsonSchema/properties.js";
+import { non_empty_array_property, } from "./TypesDiscovery/non_empty_array_property.js";
+import { $ref, common_$ref, } from "./TypesDiscovery/JsonSchema/$ref.js";
+import { non_array_object_property, } from "./TypesDiscovery/non_array_object_property.js";
 import { compile, } from '@satisfactory-dev/ajv-utilities';
-import { local_ref, } from './StringStartsWith';
-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 { local_ref, } from "./StringStartsWith.js";
+import { typed_string, } from "./TypesDiscovery/CustomParsingTypes/typed_string.js";
+import { ConstString, } from "./TypesDiscovery/JsonSchema/const.js";
+import { EnumString, } from "./TypesDiscovery/JsonSchema/enum.js";
+import { UnrealEngineString, } from "./TypesDiscovery/CustomParsingTypes/UnrealEngineString.js";
 import common_schema from '../schema/common.schema.json' with { type: 'json' };
 export class TypesDiscovery {
     discovery;
@@ -29,7 +29,7 @@ export class TypesDiscovery {
                 discovered_types: [...discovered_types.values()],
                 missed_types: Object.keys(object_has_property(schema, '$defs', value_is_non_array_object)
                     ? schema.$defs
-                    : {}).map(local_ref).filter(maybe => !discovered_types.has(maybe)),
+                    : {}).map(local_ref).filter((maybe) => !discovered_types.has(maybe)),
                 schema_$defs: Object.keys(schema.$defs),
             });
         }

package/lib/TypesGeneration/validators.js

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { create_modifiers, create_type, createParameter, type_reference_node, } from '../TsFactoryWrapper';
+import { create_modifiers, create_type, createParameter, type_reference_node, } from "../TsFactoryWrapper.js";
 export const string_starts_with = {
     file: 'utils/validators.ts',
     node: ts.factory.createTypeAliasDeclaration(create_modifiers('export'), ts.factory.createIdentifier('StringStartsWith'), [

package/lib/TypesGeneration.js

@@ -1,5 +1,4 @@
 import ts from 'typescript';
-import { NoMatchError, } from './Exceptions';
 export class ImportTracker {
     imports = {};
     get number_of_files() {
@@ -26,9 +25,6 @@ export class ImportTracker {
             }));
             for (const inner_entry of Object.entries(file_imports)) {
                 const [from, import_these] = inner_entry;
-                if (from.endsWith('.ts')) {
-                    throw new NoMatchError(from, 'files ending with .ts should not end up here');
-                }
                 if (import_these.length) {
                     if (!(from in merge_here)) {
                         merge_here[from] = import_these;

package/lib/generator.d.ts

@@ -1,3 +1,3 @@
-export * from './DocsTsGenerator';
-export * from './DocsValidation';
-export * from './TypeDefinitionWriter';
+export * from './DocsTsGenerator.ts';
+export * from './DocsValidation.ts';
+export * from './TypeDefinitionWriter.ts';

package/lib/generator.js

@@ -1,3 +1,3 @@
-export * from './DocsTsGenerator';
-export * from './DocsValidation';
-export * from './TypeDefinitionWriter';
+export * from "./DocsTsGenerator.js";
+export * from "./DocsValidation.js";
+export * from "./TypeDefinitionWriter.js";

package/lib/helpers.d.ts

@@ -1,4 +1,4 @@
-import { DocsTsGenerator } from './DocsTsGenerator';
+import { DocsTsGenerator } from './DocsTsGenerator.ts';
 export declare const docs: DocsTsGenerator;
 export declare const skip_because_docs_dot_json_not_yet_bundled: {
     skip: string | boolean;