@satisfactory-dev/docs.json.ts 0.6.1

package/lib/CustomParsingTypes/TypedStringEnum.js

@@ -0,0 +1,36 @@
+import { object_has_non_empty_array_property, object_has_property, SupportedSubSchemaType, value_is_non_array_object, } from './CustomPairingTypes';
+import { typed_string_const_value_regex, typed_string_const_value_regex__native, } from './TypedStringConst';
+import { is_string, } from '../StringStartsWith';
+export const typed_string_enum_schema = {
+    type: 'object',
+    required: ['type', 'enum'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        enum: {
+            type: 'array',
+            minItems: 1,
+            items: {
+                type: 'string',
+                pattern: typed_string_const_value_regex,
+            },
+        },
+    },
+};
+class TypedStringEnum extends SupportedSubSchemaType {
+    is_supported_schema(maybe) {
+        return (value_is_non_array_object(maybe)
+            && 2 === Object.keys(maybe).length
+            && object_has_property(maybe, 'type')
+            && 'string' === maybe.type
+            && object_has_non_empty_array_property(maybe, 'enum')
+            && maybe.enum.every((e) => is_string(e)
+                && typed_string_const_value_regex__native.test(e)));
+    }
+    value_regex(value) {
+        const enums = `(?:${value.enum.join('|')})`;
+        return `(?:${enums}|"${enums}")`;
+    }
+}
+export const typed_string_enum = new TypedStringEnum();
+//# sourceMappingURL=TypedStringEnum.js.map

package/lib/CustomParsingTypes/TypedStringPattern.d.ts

@@ -0,0 +1,64 @@
+import { SupportedSubSchemaType } from './CustomPairingTypes';
+export type pattern_schema_type = {
+    type: 'string';
+    pattern: '^\\d+\\.\\d{6}$' | '^-?\\d+\\.\\d{6}$' | '^\\d+$' | '^-?\\d+$';
+};
+export declare const typed_string_pattern_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        pattern: {
+            type: string;
+            enum: string[];
+        };
+    };
+};
+export type pattern_schema_general_type = {
+    type: 'string';
+    pattern: `^\\^\\[A-Z\\]\\[A-Za-z\\]\\+\\([_ ]\\[A-Z\\]\\[A-Za-z\\]\\+\\)\\*\\$$`;
+};
+export declare const typed_string_pattern_general_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        pattern: {
+            type: string;
+            enum: string[];
+        };
+    };
+};
+export declare const typed_string_pattern_general_schema_self_testing: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        pattern: {
+            oneOf: {
+                type: string;
+                pattern: string;
+            }[];
+        };
+    };
+};
+export declare function typed_string_pattern_value_regex(value: pattern_schema_type): string;
+export declare function typed_string_pattern_is_supported_schema(maybe: unknown): maybe is pattern_schema_type;
+declare class TypedStringPatternGeneral extends SupportedSubSchemaType<pattern_schema_general_type> {
+    is_supported_schema(maybe: unknown): maybe is pattern_schema_general_type;
+    value_regex(value: pattern_schema_general_type): string;
+}
+export declare const typed_string_pattern_general: TypedStringPatternGeneral;
+export {};

package/lib/CustomParsingTypes/TypedStringPattern.js

@@ -0,0 +1,82 @@
+import { object_has_property, object_has_property_that_equals, SupportedSubSchemaType, value_is_non_array_object, } from './CustomPairingTypes';
+import { is_string, } from '../StringStartsWith';
+export const typed_string_pattern_schema = {
+    type: 'object',
+    required: ['type', 'pattern'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        pattern: {
+            type: 'string',
+            enum: [
+                '^\\d+\\.\\d{6}$',
+                '^-?\\d+\\.\\d{6}$',
+                '^\\d+$',
+                '^-?\\d+$',
+            ],
+        },
+    },
+};
+export const typed_string_pattern_general_schema = {
+    type: 'object',
+    required: ['type', 'pattern'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        pattern: {
+            type: 'string',
+            enum: [
+                `^\\^\\[A-Z\\]\\[A-Za-z\\]\\+\\([_ ]\\[A-Z\\]\\[A-Za-z\\]\\+\\)\\*\\$$`,
+            ],
+        },
+    },
+};
+const typed_string_pattern_general_schema_oneOf = typed_string_pattern_general_schema.properties.pattern.enum.map((pattern) => {
+    return {
+        type: 'string',
+        pattern,
+    };
+});
+export const typed_string_pattern_general_schema_self_testing = {
+    type: 'object',
+    required: ['type', 'pattern'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        pattern: {
+            oneOf: typed_string_pattern_general_schema_oneOf,
+        },
+    },
+};
+const typed_string_pattern_general_schema_enum_regex = typed_string_pattern_general_schema.properties.pattern.enum.map((e) => {
+    return new RegExp(e);
+});
+export function typed_string_pattern_value_regex(value) {
+    return `(?:${value.pattern.substring(1, value.pattern.length - 1)})`;
+}
+export function typed_string_pattern_is_supported_schema(maybe) {
+    return (value_is_non_array_object(maybe)
+        && 2 === Object.keys(maybe).length
+        && object_has_property(maybe, 'type')
+        && 'string' === maybe.type
+        && object_has_property(maybe, 'pattern', is_string)
+        && typed_string_pattern_schema.properties.pattern.enum.includes(maybe.pattern));
+}
+function is_supported_pattern_string(e) {
+    return (is_string(e)
+        && !!typed_string_pattern_general_schema_enum_regex.find((regex) => regex.test(e)));
+}
+class TypedStringPatternGeneral extends SupportedSubSchemaType {
+    is_supported_schema(maybe) {
+        return (value_is_non_array_object(maybe)
+            && 2 === Object.keys(maybe).length
+            && object_has_property_that_equals(maybe, 'type', 'string')
+            && object_has_property(maybe, 'pattern', is_supported_pattern_string));
+    }
+    value_regex(value) {
+        const regex = `(?:${value.pattern.substring(1, value.pattern.length - 1)})`;
+        return `(?:${regex}|"${regex}")`;
+    }
+}
+export const typed_string_pattern_general = new TypedStringPatternGeneral();
+//# sourceMappingURL=TypedStringPattern.js.map

package/lib/CustomParsingTypes/UnrealEngineString.d.ts

@@ -0,0 +1,215 @@
+import Ajv from 'ajv/dist/2020';
+import ts, { StringLiteral, TypeNode, TypeReferenceNode, UnionTypeNode } from 'typescript';
+import { entry } from '../FilesGenerator';
+export declare const UnrealEngineString_regex: RegExp;
+export declare const UnrealEngineString_general_regex = "/(?:[A-Z-][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-Z][A-Za-z_]+\\.[A-Z][A-Za-z_]+)";
+export type UnrealEngineString_string_or_string_array = string | [string, ...string[]];
+export declare function string_or_string_array_to_node(value: string | [string, ...string[]]): typeof value extends string ? (ts.LiteralTypeNode & {
+    literal: StringLiteral;
+}) : UnionTypeNode;
+export type UnrealEngineString_right = UnrealEngineString_string_or_string_array | {
+    starts_with: UnrealEngineString_string_or_string_array;
+};
+export type UnrealEngineString_type = {
+    left: UnrealEngineString_string_or_string_array;
+    right: UnrealEngineString_right;
+} | {
+    left: UnrealEngineString_string_or_string_array;
+} | {
+    right: UnrealEngineString_right;
+} | true;
+export type UnrealEngineString_parent_type = {
+    type: 'string';
+    minLength: 1;
+    UnrealEngineString: UnrealEngineString_type;
+};
+export declare function is_UnrealEngineString_parent(maybe: unknown): maybe is UnrealEngineString_parent_type;
+export declare const UnrealEngineString_schema_definitions: {
+    UnrealEngineString_left_string: {
+        type: string;
+        pattern: string;
+    };
+    UnrealEngineString_right_string: {
+        type: string;
+        pattern: string;
+    };
+    UnrealEngineString_left: {
+        oneOf: ({
+            $ref: "#/$defs/UnrealEngineString_left_string";
+            type?: undefined;
+            minItems?: undefined;
+            items?: undefined;
+        } | {
+            type: string;
+            minItems: number;
+            items: {
+                $ref: "#/$defs/UnrealEngineString_left_string";
+            };
+            $ref?: undefined;
+        })[];
+    };
+    UnrealEngineString_right_starts_with: {
+        type: string;
+        pattern: string;
+    };
+    UnrealEngineString_right: {
+        oneOf: ({
+            $ref: "#/$defs/UnrealEngineString_right_string";
+            type?: undefined;
+            minItems?: undefined;
+            items?: undefined;
+            required?: undefined;
+            additionalProperties?: undefined;
+            properties?: undefined;
+        } | {
+            type: string;
+            minItems: number;
+            items: {
+                $ref: "#/$defs/UnrealEngineString_right_string";
+            };
+            $ref?: undefined;
+            required?: undefined;
+            additionalProperties?: undefined;
+            properties?: undefined;
+        } | {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                starts_with: {
+                    oneOf: ({
+                        $ref: "#/$defs/UnrealEngineString_right_starts_with";
+                        type?: undefined;
+                        minItems?: undefined;
+                        items?: undefined;
+                    } | {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            $ref: "#/$defs/UnrealEngineString_right_starts_with";
+                        };
+                        $ref?: undefined;
+                    })[];
+                };
+            };
+            $ref?: undefined;
+            minItems?: undefined;
+            items?: undefined;
+        })[];
+    };
+};
+export declare const UnrealEngineString_schema: {
+    oneOf: ({
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            left: {
+                $ref: "#/$defs/UnrealEngineString_left";
+            };
+            right: {
+                $ref: "#/$defs/UnrealEngineString_right";
+            };
+        };
+        const?: undefined;
+    } | {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            left: {
+                $ref: "#/$defs/UnrealEngineString_left";
+            };
+            right?: undefined;
+        };
+        const?: undefined;
+    } | {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            right: {
+                $ref: "#/$defs/UnrealEngineString_right";
+            };
+            left?: undefined;
+        };
+        const?: undefined;
+    } | {
+        type: string;
+        const: boolean;
+        required?: undefined;
+        additionalProperties?: undefined;
+        properties?: undefined;
+    })[];
+};
+export declare const UnrealEngineString_parent_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        minLength: {
+            type: string;
+            const: number;
+        };
+        UnrealEngineString: {
+            oneOf: ({
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    left: {
+                        $ref: "#/$defs/UnrealEngineString_left";
+                    };
+                    right: {
+                        $ref: "#/$defs/UnrealEngineString_right";
+                    };
+                };
+                const?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    left: {
+                        $ref: "#/$defs/UnrealEngineString_left";
+                    };
+                    right?: undefined;
+                };
+                const?: undefined;
+            } | {
+                type: string;
+                required: string[];
+                additionalProperties: boolean;
+                properties: {
+                    right: {
+                        $ref: "#/$defs/UnrealEngineString_right";
+                    };
+                    left?: undefined;
+                };
+                const?: undefined;
+            } | {
+                type: string;
+                const: boolean;
+                required?: undefined;
+                additionalProperties?: undefined;
+                properties?: undefined;
+            })[];
+        };
+    };
+};
+export declare const UnrealEngineString_left_default: string[];
+export declare class UnrealEngineString {
+    private static already_configured;
+    static ajv_macro_generator(inner: boolean): (data_from_schema: UnrealEngineString_type) => {
+        pattern: string;
+    };
+    static configure_ajv(ajv: Ajv): void;
+    static CustomGenerators(): [entry, ...entry[]];
+}
+export declare function adjust_unrealengine_value(value: string): string;
+export declare function flexibly_create_UnrealEngineString_reference_type(type_arguments: [TypeNode, TypeNode] | [TypeNode] | undefined): ts.TypeReferenceNode;
+export declare function UnrealEngineString_reference_type(data_from_schema: UnrealEngineString_type): TypeReferenceNode;