@satisfactory-dev/docs.json.ts 0.16.0 → 0.17.0

package/lib/CustomParsingTypes/UnrealEngineString.js

@@ -1,16 +1,17 @@
 import ts from 'typescript';
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { adjust_class_name, create_const_statement, create_index_access, create_literal, create_method_with_type_parameters, create_method_without_type_parameters, create_modifiers, create_property_access, create_this_assignment, create_throw_if, create_type, createClass, createParameter, not, parenthesize, possibly_create_lazy_union, template_expression_from_string, type_reference_node, variable, } from '../TsFactoryWrapper';
-import { local_ref, } from '../StringStartsWith';
+import { adjust_class_name, create_const_statement, create_index_access, create_literal, create_method_with_type_parameters, create_method_without_type_parameters, create_modifiers, create_property_access, create_this_assignment, create_throw_if, create_type, createClass, createParameter, not, parenthesize, possibly_create_lazy_union, template_expression_from_string, type_reference_node, variable, } from "../TsFactoryWrapper.js";
+import { local_ref, } from "../StringStartsWith.js";
 export const UnrealEngineString_regex = /^([^']+)'(?:"([^"]+)"|([^"]+))'$/;
-// eslint-disable-next-line max-len
+// eslint-disable-next-line @stylistic/max-len
 export const UnrealEngineString_regex_quoted = /^"([^']+)'(?:"([^"]+)"|([^"]+))'"$/;
+// eslint-disable-next-line @stylistic/max-len
 export const UnrealEngineString_general_regex = `/(?:[A-Z3-][A-Za-z0-9_-]+/)+(?:_?[A-Z][A-Za-z_0-9-]+\\.[A-Z][A-Za-z_0-9-]+(?:_C)?(?::[A-Z][A-Za-z0-9_]+)?|[A-Z0-9][A-Za-z_]+\\.[A-Z0-9][A-Za-z_]+)`;
 export function string_or_string_array_to_node(value) {
     if (is_string(value)) {
         return create_literal(value);
     }
-    return ts.factory.createUnionTypeNode(value.map(e => create_literal(e)));
+    return ts.factory.createUnionTypeNode(value.map((e) => create_literal(e)));
 }
 export function is_UnrealEngineString_parent(maybe) {
     return (value_is_non_array_object(maybe)
@@ -56,7 +57,9 @@ export const UnrealEngineString_schema_definitions = {
     },
     UnrealEngineString_right_starts_with: {
         type: 'string',
-        pattern: `^/(?:_?[A-Z][A-Za-z_\\-.]+/)+(?:[A-Z][A-Za-z_\\-.]+/|[A-Z][A-Za-z_\\-.]+\\.[A-Z][A-Za-z_\\-]+)$`,
+        pattern: 
+        // eslint-disable-next-line @stylistic/max-len
+        `^/(?:_?[A-Z][A-Za-z_\\-.]+/)+(?:[A-Z][A-Za-z_\\-.]+/|[A-Z][A-Za-z_\\-.]+\\.[A-Z][A-Za-z_\\-]+)$`,
     },
     UnrealEngineString_right: { oneOf: [
             {
@@ -164,36 +167,34 @@ export const UnrealEngineString_parent_schema = {
 export const UnrealEngineString_left_default = [
     '/Script/Engine.BlueprintGeneratedClass',
 ];
-const right_value_starts_with_suffix = 
-// eslint-disable-next-line max-len
-'(?:_?[A-Z0-9][A-Za-z0-9_.]+/)*[A-Z0-9][A-Za-z_.0-9-]+(?::[A-Z0-9][A-Za-z0-9]+)?';
+// eslint-disable-next-line @stylistic/max-len
+const right_value_starts_with_suffix = '(?:_?[A-Z0-9][A-Za-z0-9_.]+/)*[A-Z0-9][A-Za-z_.0-9-]+(?::[A-Z0-9][A-Za-z0-9]+)?';
 export class UnrealEngineString {
     static already_configured = new WeakSet();
-    // eslint-disable-next-line max-len
+    // eslint-disable-next-line @stylistic/max-len
     static quote_mode = 'both';
     static ajv_macro_generator(inner) {
         return (data_from_schema) => {
             const data = (true === data_from_schema
-                || is_string(data_from_schema)) ? {} : data_from_schema;
+                || is_string(data_from_schema))
+                ? {}
+                : data_from_schema;
             const left_value = ('left' in data
                 ? data.left instanceof Array
                     ? data.left
                     : [data.left]
                 : UnrealEngineString_left_default).join('|');
-            const right_value = 'right' in data
+            const right_value = ('right' in data
                 ? `(?:${(data.right instanceof Array
                     ? data.right
                     : [
                         is_string(data.right)
                             ? data.right
-                            : `(?:${(data.right
-                                .starts_with instanceof Array
+                            : `(?:${(data.right.starts_with instanceof Array
                                 ? data.right.starts_with
-                                : [data.right.starts_with])
-                                .map((starts_with) => `${starts_with}${right_value_starts_with_suffix}`)
-                                .join('|')})`,
+                                : [data.right.starts_with]).map((starts_with) => `${starts_with}${right_value_starts_with_suffix}`).join('|')})`,
                     ]).join('|')})`
-                : UnrealEngineString_general_regex;
+                : UnrealEngineString_general_regex);
             let regex = `(?:(?:${left_value})'(?:${right_value}|"${right_value}")'|"(?:${left_value})'${right_value}'"|\\\\"(?:${left_value})'${right_value}'\\\\")`;
             let quote_mode = this.quote_mode;
             if (is_string(data_from_schema)) {
@@ -252,12 +253,10 @@ export class UnrealEngineString {
                 createParameter('value', create_type('string')),
             ], [
                 ts.factory.createIfStatement(ts.factory.createBinaryExpression(ts.factory.createCallExpression(create_property_access(ts.factory.createIdentifier('value'), 'startsWith'), undefined, [ts.factory.createStringLiteral('"')]), ts.SyntaxKind.AmpersandAmpersandToken, ts.factory.createCallExpression(create_property_access(ts.factory.createIdentifier('value'), 'endsWith'), undefined, [ts.factory.createStringLiteral('"')])), 
-                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @stylistic/max-len
                 ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createIdentifier('value'), ts.SyntaxKind.EqualsToken, ts.factory.createCallExpression(create_property_access(ts.factory.createIdentifier('value'), 'substring'), undefined, [
                     ts.factory.createNumericLiteral(1),
-                    ts.factory.createBinaryExpression(
-                    // eslint-disable-next-line max-len
-                    create_property_access(ts.factory.createIdentifier('value'), 'length'), ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(1)),
+                    ts.factory.createBinaryExpression(create_property_access(ts.factory.createIdentifier('value'), 'length'), ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(1)),
                 ])))),
                 create_const_statement(variable('result', ts.factory.createCallExpression(create_property_access(ts.factory.createRegularExpressionLiteral(UnrealEngineString_regex.toString()), 'exec'), undefined, [
                     ts.factory.createIdentifier('value'),
@@ -333,10 +332,9 @@ export function UnrealEngineString_reference_type(data_from_schema) {
                 ...new Set(right instanceof Array ? right : [right]).values(),
             ];
             if (right_options.length >= 1) {
-                right_value =
-                    1 === right_options.length
-                        ? create_literal(right_options[0])
-                        : possibly_create_lazy_union(right_options);
+                right_value = 1 === right_options.length
+                    ? create_literal(right_options[0])
+                    : possibly_create_lazy_union(right_options);
             }
         }
         right_changed = true;
@@ -359,12 +357,12 @@ function is_UnrealEngineString_object(maybe) {
     }
     const keys = Object.keys(maybe);
     const has_left = 'left' in maybe && is_string_or_string_array(maybe.left);
-    const has_right = object_has_property(maybe, 'right')
+    const has_right = (object_has_property(maybe, 'right')
         && (value_is_non_array_object(maybe.right)
-            ? 'starts_with' in maybe.right
+            ? ('starts_with' in maybe.right
                 && 1 === Object.keys(maybe.right).length
-                && is_string_or_string_array(maybe.right.starts_with)
-            : is_string_or_string_array(maybe.right));
+                && is_string_or_string_array(maybe.right.starts_with))
+            : is_string_or_string_array(maybe.right)));
     const has_quote_mode = ('quote_mode' in maybe
         && is_string(maybe.quote_mode)
         && [

package/lib/CustomParsingTypes/ValueToRegexFormatter.d.ts

@@ -1,4 +1,4 @@
-import { SchemaObject } from 'ajv/dist/2020';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class ValueToRegexFormatter {
     private typed_string_const;
     private typed_string_enum;

package/lib/CustomParsingTypes/ValueToRegexFormatter.js

@@ -1,11 +1,11 @@
 import { is_non_empty_array, is_string, object_has_non_empty_array_property, object_has_property, object_has_property_that_equals, object_only_has_that_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { annoyingly_have_to_escape_property, } from './CustomPairingTypes';
-import { common_ref, local_ref, } from '../StringStartsWith';
-import { NoMatchError, } from '../Exceptions';
-import { is_UnrealEngineString_parent, UnrealEngineString, } from './UnrealEngineString';
-import { typed_string_const, } from './TypedStringConst';
-import { typed_string_enum, } from './TypedStringEnum';
-import { typed_string_pattern_general, typed_string_pattern_is_supported_schema, typed_string_pattern_value_regex, } from './TypedStringPattern';
+import { annoyingly_have_to_escape_property, } from "./CustomPairingTypes.js";
+import { common_ref, local_ref, } from "../StringStartsWith.js";
+import { NoMatchError, } from "../Exceptions.js";
+import { is_UnrealEngineString_parent, UnrealEngineString, } from "./UnrealEngineString.js";
+import { typed_string_const, } from "./TypedStringConst.js";
+import { typed_string_enum, } from "./TypedStringEnum.js";
+import { typed_string_pattern_general, typed_string_pattern_is_supported_schema, typed_string_pattern_value_regex, } from "./TypedStringPattern.js";
 function is_number(maybe) {
     return 'number' === typeof maybe;
 }
@@ -17,7 +17,6 @@ export class ValueToRegexFormatter {
     $defs;
     common_$defs;
     supported_$ref_object;
-    // eslint-disable-next-line max-len
     supported_common_$ref_object;
     constructor($defs, common_$defs) {
         this.$defs = $defs;
@@ -27,7 +26,7 @@ export class ValueToRegexFormatter {
         this.typed_string_enum = typed_string_enum;
         this.typed_string_pattern_general = typed_string_pattern_general;
         this.supported_$ref_object = this.prepare_$ref_regex($defs);
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/max-len
         this.supported_common_$ref_object = this.prepare_common_$ref_regex(common_$defs);
     }
     pattern_from_value(value) {
@@ -59,7 +58,7 @@ export class ValueToRegexFormatter {
             || ValueToRegexFormatter.is_typed_string_object_parent(maybe)
             || (object_only_has_that_property(maybe, 'oneOf')
                 && is_non_empty_array(maybe.oneOf, value_is_non_array_object)
-                && maybe.oneOf.every(e => this.is_supported_definition(e))));
+                && maybe.oneOf.every((e) => this.is_supported_definition(e))));
     }
     is_Texture2D_basic(maybe) {
         return (value_is_non_array_object(maybe)
@@ -69,9 +68,9 @@ export class ValueToRegexFormatter {
     }
     prepare_$ref_regex($defs) {
         return Object.fromEntries(Object.entries($defs)
-            .filter(maybe => {
+            .filter((maybe) => {
             return this.is_supported_definition(maybe[1]);
-        }).map(entry => {
+        }).map((entry) => {
             return [
                 local_ref(entry[0]),
                 this.value_to_regex(entry[1]),
@@ -80,9 +79,9 @@ export class ValueToRegexFormatter {
     }
     prepare_common_$ref_regex($defs) {
         return Object.fromEntries(Object.entries($defs)
-            .filter(maybe => {
+            .filter((maybe) => {
             return this.is_supported_definition(maybe[1]);
-        }).map(entry => {
+        }).map((entry) => {
             return [
                 common_ref(entry[0]),
                 this.value_to_regex(entry[1]),
@@ -90,6 +89,7 @@ export class ValueToRegexFormatter {
         }));
     }
     Texture2D_basic_regex() {
+        // eslint-disable-next-line @stylistic/max-len
         return `(?:Texture2D \\/Game\\/FactoryGame\\/(?:[A-Z][A-Za-z0-9_.]+/)*[A-Z][A-Za-z_.0-9-]+(?::[A-Z][A-Za-z0-9]+)?)`;
     }
     typed_string_array_inner_to_regex(typed_string_array) {
@@ -152,7 +152,7 @@ export class ValueToRegexFormatter {
             return this.UnrealEngineString(value.UnrealEngineString).pattern;
         }
         else if (object_has_non_empty_array_property(value, 'oneOf')) {
-            return `(?:${value.oneOf.map(e => this.value_to_regex(e)).join('|')})`;
+            return `(?:${value.oneOf.map((e) => this.value_to_regex(e)).join('|')})`;
         }
         else if (object_only_has_that_property(value, '$ref', is_string)
             && value.$ref.startsWith('#/$defs/')
@@ -209,7 +209,7 @@ export class ValueToRegexFormatter {
             return this.Texture2D_basic_regex();
         }
         else if (ValueToRegexFormatter.is_typed_string_array_prefixItems(value)) {
-            const item_regex = `\\(${value.prefixItems.map(e => this.value_to_regex(e)).join(', ')}\\)`;
+            const item_regex = `\\(${value.prefixItems.map((e) => this.value_to_regex(e)).join(', ')}\\)`;
             return `(?:\\(${item_regex}(?:,${item_regex}){${Math.max(0, value.minItems - 1)},${value.maxItems
                 ? Math.max(1, value.maxItems - 1)
                 : ''}}\\))`;

package/lib/DataDiscovery/CustomTypes/BooleanOrBooleanExtended.d.ts

@@ -1,7 +1,8 @@
-import Ajv, { SchemaObject } from 'ajv/dist/2020';
-import { common_ref, local_ref } from '../../StringStartsWith';
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { FalseLiteral, NullLiteral, TrueLiteral } from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import { common_ref, local_ref } from '../../StringStartsWith.ts';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type { FalseLiteral, NullLiteral, TrueLiteral } from 'typescript';
 export type schema_type = SchemaObject & {
     $ref: (local_ref<'boolean' | 'boolean-extended'> | common_ref<'boolean' | 'boolean-extended'>);
 };

package/lib/DataDiscovery/CustomTypes/BooleanOrBooleanExtended.js

@@ -1,5 +1,5 @@
-import { common_ref, local_ref, } from '../../StringStartsWith';
-import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { common_ref, local_ref, } from "../../StringStartsWith.js";
+import { ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
 import ts from 'typescript';
 const schema = {
     type: 'object',

package/lib/DataDiscovery/CustomTypes/StringStartsWith.d.ts

@@ -1,7 +1,9 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import Ajv, { SchemaObject } from 'ajv/dist/2020';
-import { RawData } from '../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
-import ts, { AsExpression } from 'typescript';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type Ajv from 'ajv/dist/2020.js';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { RawData } from '../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.ts';
+import type { AsExpression } from 'typescript';
+import ts from 'typescript';
 export declare class StringStartsWithConverter extends ConverterMatchesSchema<RawData, string, AsExpression> {
     constructor(ajv: Ajv);
     can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;

package/lib/DataDiscovery/CustomTypes/StringStartsWith.js

@@ -1,8 +1,10 @@
-import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
-import { schema, } from '../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with';
+import { ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
+import { schema,
+// eslint-disable-next-line @stylistic/max-len
+ } from "../../TypeDefinitionDiscovery/CustomParsingTypes/string_starts_with.js";
 import { is_string, } from '@satisfactory-dev/predicates.ts';
 import ts from 'typescript';
-import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
+import { create_literal, type_reference_node, } from "../../TsFactoryWrapper.js";
 export class StringStartsWithConverter extends ConverterMatchesSchema {
     constructor(ajv) {
         super(ajv, schema);

package/lib/DataDiscovery/CustomTypes/TypedString.d.ts

@@ -1,8 +1,8 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { typed_string_parent_type } from '../../CustomParsingTypes/TypedString';
-import { SchemaObject } from 'ajv/dist/2020';
-import { DataDiscovery } from '../../DataDiscovery';
-import { ArrayLiteralExpression, ObjectLiteralExpression } from 'typescript';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type { typed_string_parent_type } from '../../CustomParsingTypes/TypedString.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { ArrayLiteralExpression, ObjectLiteralExpression } from 'typescript';
 export declare class TypedStringConverter extends ConverterMatchesSchema<typed_string_parent_type, string, ArrayLiteralExpression | ObjectLiteralExpression> {
     private readonly $defs;
     private readonly discovery;

package/lib/DataDiscovery/CustomTypes/TypedString.js

@@ -1,11 +1,11 @@
 import { is_string, } from '@satisfactory-dev/predicates.ts';
-import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
-import { generate_object_parent_schema, generate_typed_string_$defs, } from '../../CustomParsingTypes/TypedString';
-import { common_ref, local_ref, } from '../../StringStartsWith';
-import { NoMatchError, } from '../../Exceptions';
-import { string_to_array, string_to_object, } from '../../DocsValidation';
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
+import { generate_object_parent_schema, generate_typed_string_$defs, } from "../../CustomParsingTypes/TypedString.js";
+import { common_ref, local_ref, } from "../../StringStartsWith.js";
+import { NoMatchError, } from "../../Exceptions.js";
+import { string_to_array, string_to_object, } from "../../DocsValidation.js";
 import { compile, } from '@satisfactory-dev/ajv-utilities';
-import { typed_string, } from '../../TypeDefinitionDiscovery/CustomParsingTypes/typed_string';
+import { typed_string, } from "../../TypeDefinitionDiscovery/CustomParsingTypes/typed_string.js";
 import assert from 'node:assert/strict';
 export class TypedStringConverter extends ConverterMatchesSchema {
     $defs;
@@ -197,7 +197,7 @@ export class TypedStringConverter extends ConverterMatchesSchema {
             });
             performance.measure(`${this.constructor.name}.convert_object_property_schema() pattern caching`, `${this.constructor.name}.convert_object_property_schema() start`);
         }
-        const property_regex_schema = this.regex_schema_cache[json_string].find(maybe => maybe[0].test(property));
+        const property_regex_schema = this.regex_schema_cache[json_string].find((maybe) => maybe[0].test(property));
         if (!property_regex_schema) {
             performance.measure(`${this.constructor.name}.convert_object_property_schema() pattern failure`, `${this.constructor.name}.convert_object_property_schema() start`);
             throw new NoMatchError({

package/lib/DataDiscovery/CustomTypes/UnrealEngineString.d.ts

@@ -1,7 +1,7 @@
-import { Converter, ExpressionResult } from '../Generator';
-import { UnrealEngineString_parent_type } from '../../CustomParsingTypes/UnrealEngineString';
-import { CallExpression } from 'typescript';
-import { SchemaObject } from 'ajv';
+import { Converter, ExpressionResult } from '../Generator.ts';
+import type { UnrealEngineString_parent_type } from '../../CustomParsingTypes/UnrealEngineString.ts';
+import type { CallExpression } from 'typescript';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 export declare class UnrealEngineStringConverter extends Converter<UnrealEngineString_parent_type, string, CallExpression> {
     can_convert_schema(schema: SchemaObject): schema is UnrealEngineString_parent_type;
     can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;

package/lib/DataDiscovery/CustomTypes/UnrealEngineString.js

@@ -1,9 +1,9 @@
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { Converter, ExpressionResult, } from '../Generator';
-import { is_UnrealEngineString_parent, string_or_string_array_to_node, UnrealEngineString_regex, UnrealEngineString_regex_quoted, } from '../../CustomParsingTypes/UnrealEngineString';
+import { Converter, ExpressionResult, } from "../Generator.js";
+import { is_UnrealEngineString_parent, string_or_string_array_to_node, UnrealEngineString_regex, UnrealEngineString_regex_quoted, } from "../../CustomParsingTypes/UnrealEngineString.js";
 import ts from 'typescript';
-import { create_literal, create_property_access, create_type, type_reference_node, } from '../../TsFactoryWrapper';
-import { NoMatchError, } from '../../Exceptions';
+import { create_literal, create_property_access, create_type, type_reference_node, } from "../../TsFactoryWrapper.js";
+import { NoMatchError, } from "../../Exceptions.js";
 export class UnrealEngineStringConverter extends Converter {
     can_convert_schema(schema) {
         return is_UnrealEngineString_parent(schema);

package/lib/DataDiscovery/Generator.d.ts

@@ -1,5 +1,6 @@
-import { Expression } from 'typescript';
-import Ajv, { SchemaObject, ValidateFunction } from 'ajv/dist/2020';
+import type { Expression } from 'typescript';
+import type Ajv from 'ajv/dist/2020.js';
+import type { SchemaObject, ValidateFunction } from 'ajv/dist/2020.js';
 export declare abstract class Converter<Schema extends SchemaObject, RawData = unknown, Output extends Expression = Expression> {
     abstract can_convert_schema(schema: SchemaObject): schema is Schema;
     abstract can_convert_schema_and_raw_data(schema: SchemaObject, raw_data: unknown): Promise<boolean>;

package/lib/DataDiscovery/Generator.js

@@ -1,4 +1,4 @@
-import { NoMatchError, } from '../Exceptions';
+import { NoMatchError, } from "../Exceptions.js";
 import { compile, } from '@satisfactory-dev/ajv-utilities';
 export class Converter {
     static find_matching_schema(candidates, schema) {
@@ -11,7 +11,7 @@ export class Converter {
         }, 'Could not identify suitable candidate!'));
     }
     static has_matching_schema(candidates, schema) {
-        return candidates.find(e => e.can_convert_schema(schema));
+        return candidates.find((e) => e.can_convert_schema(schema));
     }
     static async has_matching_schema_and_raw_data(candidates, schema, raw_data) {
         for (const candidate of candidates) {

package/lib/DataDiscovery/JsonSchema/AllOf.d.ts

@@ -1,6 +1,7 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { DataDiscovery } from '../../DataDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import type { ExpressionResult } from '../Generator.ts';
+import { ConverterMatchesSchema } from '../Generator.ts';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 type allOf = {
     allOf: [SchemaObject, ...SchemaObject[]];
 };

package/lib/DataDiscovery/JsonSchema/AllOf.js

@@ -1,5 +1,5 @@
-import { Converter, ConverterMatchesSchema, } from '../Generator';
-import { NoMatchError, } from '../../Exceptions';
+import { Converter, ConverterMatchesSchema, } from "../Generator.js";
+import { NoMatchError, } from "../../Exceptions.js";
 const schema = {
     type: 'object',
     required: ['allOf'],
@@ -58,13 +58,13 @@ export class AllOfConverter extends ConverterMatchesSchema {
             raw_data,
             failures,
             allOf: await Promise.all(schema.allOf.map(async (e) => {
-                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @stylistic/max-len
                 const converter = await Converter.has_matching_schema_and_raw_data(candidates, e, raw_data);
                 return [
                     e,
                     converter,
                     (converter
-                        // eslint-disable-next-line max-len
+                        // eslint-disable-next-line @stylistic/max-len
                         ? await converter.can_convert_schema_and_raw_data(e, raw_data)
                         : 'no converter'),
                 ];

package/lib/DataDiscovery/JsonSchema/Array.d.ts

@@ -1,7 +1,7 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { DataDiscovery } from '../../DataDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
-import { ArrayLiteralExpression } from 'typescript';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { ArrayLiteralExpression } from 'typescript';
 type array_type = {
     type: 'array';
     items: SchemaObject;

package/lib/DataDiscovery/JsonSchema/Array.js

@@ -1,5 +1,5 @@
-import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
-import { NoMatchError, } from '../../Exceptions';
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
+import { NoMatchError, } from "../../Exceptions.js";
 export class ArrayConverter extends ConverterMatchesSchema {
     discovery;
     constructor(discovery) {
@@ -38,10 +38,10 @@ export class ArrayConverter extends ConverterMatchesSchema {
         return Promise.resolve(this.can_convert_schema(schema)
             && raw_data instanceof Array
             && ((!('prefixItems' in schema)
-                && !!((await this.discovery.candidates).find(e => e.can_convert_schema(schema.items)))
+                && !!((await this.discovery.candidates).find((e) => e.can_convert_schema(schema.items)))
                 && !!Converter.has_matching_schema(await this.discovery.candidates, schema.items))
                 || (('prefixItems' in schema)
-                    && !!await Promise.all(schema.prefixItems.map(async (sub_schema) => (!!(await this.discovery.candidates).find(e => e.can_convert_schema(sub_schema))
+                    && !!await Promise.all(schema.prefixItems.map(async (sub_schema) => (!!(await this.discovery.candidates).find((e) => e.can_convert_schema(sub_schema))
                         && !!Converter.has_matching_schema(await this.discovery.candidates, sub_schema)))))));
     }
     async convert(schema, raw_data) {

package/lib/DataDiscovery/JsonSchema/Object.d.ts

@@ -1,9 +1,9 @@
-import { Converter, ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { DataDiscovery } from '../../DataDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
-import { common_ref, local_ref } from '../../StringStartsWith';
-import { Expression, ObjectLiteralExpression } from 'typescript';
-import { typed_string_inner_object_pattern_type } from '../../CustomParsingTypes/TypedString';
+import { Converter, ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { common_ref, local_ref } from '../../StringStartsWith.ts';
+import type { Expression, ObjectLiteralExpression } from 'typescript';
+import type { typed_string_inner_object_pattern_type } from '../../CustomParsingTypes/TypedString.ts';
 export type schema_type = {
     type: 'object';
     $ref: local_ref<string>;

package/lib/DataDiscovery/JsonSchema/Object.js

@@ -1,7 +1,7 @@
-import { Converter, ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { Converter, ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
 import { is_string, object_has_property, object_only_has_that_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { NoMatchError, } from '../../Exceptions';
-import { pattern_properties_regex, } from '../../CustomParsingTypes/TypedString';
+import { NoMatchError, } from "../../Exceptions.js";
+import { pattern_properties_regex, } from "../../CustomParsingTypes/TypedString.js";
 class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
     already_resolved = {};
     discovery;
@@ -13,7 +13,7 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         return (this.can_convert_schema(schema)
             && value_is_non_array_object(raw_data)
             && 0 === this.check_converters_for_missing_keys(raw_data, await this.resolve_converters(schema)).length
-            && await new Promise((yup => {
+            && await new Promise(((yup) => {
                 this.convert(schema, raw_data).then(() => yup(true)).catch(() => yup(false));
             })));
     }
@@ -52,7 +52,7 @@ class ObjectConverterMatchesSchema extends ConverterMatchesSchema {
         }
         if (object_has_property(schema, 'properties', (maybe) => {
             return (value_is_non_array_object(maybe)
-                && Object.values(maybe).every(e => value_is_non_array_object(e)));
+                && Object.values(maybe).every((e) => value_is_non_array_object(e)));
         })) {
             const { properties } = schema;
             for (const entry of Object.entries(properties)) {

package/lib/DataDiscovery/JsonSchema/OneOf.d.ts

@@ -1,6 +1,7 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { DataDiscovery } from '../../DataDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import type { ExpressionResult } from '../Generator.ts';
+import { ConverterMatchesSchema } from '../Generator.ts';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 type oneOf = {
     oneOf: [SchemaObject, ...SchemaObject[]];
 };

package/lib/DataDiscovery/JsonSchema/OneOf.js

@@ -1,5 +1,5 @@
-import { Converter, ConverterMatchesSchema, } from '../Generator';
-import { NoMatchError, } from '../../Exceptions';
+import { Converter, ConverterMatchesSchema, } from "../Generator.js";
+import { NoMatchError, } from "../../Exceptions.js";
 const schema = {
     type: 'object',
     required: ['oneOf'],
@@ -53,13 +53,13 @@ export class OneOfConverter extends ConverterMatchesSchema {
             raw_data,
             failures,
             oneOf: await Promise.all(schema.oneOf.map(async (e) => {
-                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @stylistic/max-len
                 const converter = await Converter.has_matching_schema_and_raw_data(candidates, e, raw_data);
                 return [
                     e,
                     converter,
                     (converter
-                        // eslint-disable-next-line max-len
+                        // eslint-disable-next-line @stylistic/max-len
                         ? await converter.can_convert_schema_and_raw_data(e, raw_data)
                         : 'no converter'),
                 ];

package/lib/DataDiscovery/JsonSchema/Ref.d.ts

@@ -1,7 +1,8 @@
-import { Converter, ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import { local_ref } from '../../StringStartsWith';
-import { DataDiscovery } from '../../DataDiscovery';
-import { SchemaObject } from 'ajv/dist/2020';
+import type { ExpressionResult } from '../Generator.ts';
+import { Converter, ConverterMatchesSchema } from '../Generator.ts';
+import type { local_ref } from '../../StringStartsWith.ts';
+import type { DataDiscovery } from '../../DataDiscovery.ts';
+import type { SchemaObject } from 'ajv/dist/2020.js';
 type schema_type = {
     $ref: local_ref<string>;
 };

package/lib/DataDiscovery/JsonSchema/Ref.js

@@ -1,5 +1,5 @@
-import { Converter, ConverterMatchesSchema, } from '../Generator';
-import { NoMatchError, } from '../../Exceptions';
+import { Converter, ConverterMatchesSchema, } from "../Generator.js";
+import { NoMatchError, } from "../../Exceptions.js";
 export class Ref extends ConverterMatchesSchema {
     cache = {};
     discovery;
@@ -9,7 +9,7 @@ export class Ref extends ConverterMatchesSchema {
             required: ['$ref'],
             additionalProperties: false,
             properties: {
-                // eslint-disable-next-line max-len
+                // eslint-disable-next-line @stylistic/max-len
                 $ref: { type: 'string', pattern: '^(common.schema.json)?#/\\$defs/' },
             },
         });

package/lib/DataDiscovery/JsonSchema/StringType.d.ts

@@ -1,8 +1,9 @@
-import { ConverterMatchesSchema, ExpressionResult } from '../Generator';
-import Ajv, { SchemaObject } from 'ajv/dist/2020';
-import { enum_schema_type } from '../../CustomParsingTypes/TypedStringEnum';
-import { const_schema_type } from '../../CustomParsingTypes/TypedStringConst';
-import { AsExpression, StringLiteral } from 'typescript';
+import { ConverterMatchesSchema, ExpressionResult } from '../Generator.ts';
+import type Ajv from 'ajv/dist/2020.js';
+import type { SchemaObject } from 'ajv/dist/2020.js';
+import type { enum_schema_type } from '../../CustomParsingTypes/TypedStringEnum.ts';
+import type { const_schema_type } from '../../CustomParsingTypes/TypedStringConst.ts';
+import type { AsExpression, StringLiteral } from 'typescript';
 export type string_schema = {
     type: 'string';
     minLength?: number;

package/lib/DataDiscovery/JsonSchema/StringType.js

@@ -1,9 +1,9 @@
-import { ConverterMatchesSchema, ExpressionResult, } from '../Generator';
+import { ConverterMatchesSchema, ExpressionResult, } from "../Generator.js";
 import { is_string, object_has_property, value_is_non_array_object, } from '@satisfactory-dev/predicates.ts';
-import { NoMatchError, } from '../../Exceptions';
+import { NoMatchError, } from "../../Exceptions.js";
 import ts from 'typescript';
-import { create_literal, type_reference_node, } from '../../TsFactoryWrapper';
-import { not_matching_string_schema, } from '../../TypeDefinitionDiscovery/JsonSchema/String';
+import { create_literal, type_reference_node, } from "../../TsFactoryWrapper.js";
+import { not_matching_string_schema, } from "../../TypeDefinitionDiscovery/JsonSchema/String.js";
 import { compile, } from '@satisfactory-dev/ajv-utilities';
 class StringConverter extends ConverterMatchesSchema {
     maybe_not;

package/lib/DataDiscovery/Literal.d.ts

@@ -1,4 +1,4 @@
-import { ArrayLiteralExpression, Expression, FalseLiteral, Identifier, ObjectLiteralExpression, StringLiteral, TrueLiteral } from 'typescript';
+import type { ArrayLiteralExpression, Expression, FalseLiteral, Identifier, ObjectLiteralExpression, StringLiteral, TrueLiteral } from 'typescript';
 export declare class Literal {
     array_literal(from: unknown[]): Promise<ArrayLiteralExpression>;
     object_literal(from: {