@satisfactory-dev/docs.json.ts 0.6.1

package/lib/CustomParsingTypes/TypedString.d.ts

@@ -0,0 +1,411 @@
+import Ajv, { SchemaObject } from 'ajv/dist/2020';
+import { local_ref } from '../StringStartsWith';
+import { UnrealEngineString_parent_type } from './UnrealEngineString';
+import { const_schema_type } from './TypedStringConst';
+import { enum_schema_type } from './TypedStringEnum';
+type typed_string_sub_types = {
+    $ref: local_ref<string>;
+} | const_schema_type | enum_schema_type | UnrealEngineString_parent_type;
+type typed_string_object_type = typed_string_sub_types | typed_string_parent_type;
+export type typed_string_inner_object_type = {
+    required: [string, ...string[]];
+    properties: {
+        [key: string]: (typed_string_object_type);
+    };
+};
+export type typed_string_inner_object_pattern_type = {
+    minProperties: number;
+    patternProperties: {
+        [key: string]: (typed_string_object_type);
+    };
+};
+type typed_string_inner_array_items_type = typed_string_sub_types | typed_string_parent_type;
+export type typed_string_inner_array_type = {
+    minItems: number;
+    maxItems?: number;
+    items: typed_string_inner_array_items_type | {
+        oneOf: [
+            typed_string_inner_array_items_type,
+            ...typed_string_inner_array_items_type[]
+        ];
+    } | typed_string_inner_array_prefixItems_type;
+};
+export type typed_string_inner_array_prefixItems_type = {
+    items: false;
+    minItems: number;
+    maxItems?: number;
+    prefixItems: [typed_string_sub_types, ...typed_string_sub_types[]];
+};
+type typed_string_inner_type = typed_string_inner_object_type | typed_string_inner_object_pattern_type | typed_string_inner_array_type | typed_string_inner_array_prefixItems_type;
+export type typed_string_parent_type = {
+    type: 'string';
+    minLength: 1;
+    typed_string: typed_string_inner_type;
+};
+export declare const pattern_properties_regex = "^\\^\\([A-za-z]+(\\|[A-za-z]+)*\\)\\$$";
+export declare const pattern_properties_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        minProperties: {
+            type: string;
+            minimum: number;
+        };
+        patternProperties: {
+            type: string;
+            additionalProperties: boolean;
+            minProperties: number;
+            maxProperties: number;
+            patternProperties: {
+                "^\\^\\([A-za-z]+(\\|[A-za-z]+)*\\)\\$$": {
+                    $ref: string;
+                };
+            };
+        };
+    };
+};
+export declare function generate_object_parent_schema(): {
+    $ref: string;
+};
+export declare function generate_typed_string_$defs($defs: local_ref<string>[]): {
+    typed_string_subtypes: {
+        oneOf: ({
+            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;
+                    })[];
+                };
+            };
+        } | {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                type: {
+                    type: string;
+                    const: string;
+                };
+                const: {
+                    type: string;
+                    pattern: string;
+                };
+            };
+        } | {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                type: {
+                    type: string;
+                    const: string;
+                };
+                enum: {
+                    type: string;
+                    minItems: number;
+                    items: {
+                        type: string;
+                        pattern: string;
+                    };
+                };
+            };
+        } | {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                type: {
+                    type: string;
+                    const: string;
+                };
+                pattern: {
+                    oneOf: {
+                        type: string;
+                        pattern: string;
+                    }[];
+                };
+            };
+        } | {
+            type: string;
+            required: string[];
+            additionalProperties: boolean;
+            properties: {
+                $ref: {
+                    type: string;
+                    enum: `#/$defs/${string}`[];
+                };
+            };
+            $ref?: undefined;
+        } | {
+            $ref: string;
+            type?: undefined;
+            required?: undefined;
+            additionalProperties?: undefined;
+            properties?: undefined;
+        })[];
+    };
+    typed_string_parent_type: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            type: {
+                type: string;
+                const: string;
+            };
+            minLength: {
+                type: string;
+                const: number;
+            };
+            typed_string: {
+                oneOf: {
+                    $ref: string;
+                }[];
+            };
+        };
+    };
+    typed_string_object_type: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            required: {
+                type: string;
+                minItems: number;
+                items: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+            properties: {
+                type: string;
+                additionalProperties: boolean;
+                patternProperties: {
+                    "^[A-Za-z][A-Za-z0-9_\\[\\]]*$": {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+    };
+    typed_string_object_pattern_type: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            minProperties: {
+                type: string;
+                minimum: number;
+            };
+            patternProperties: {
+                type: string;
+                additionalProperties: boolean;
+                minProperties: number;
+                maxProperties: number;
+                patternProperties: {
+                    "^\\^\\([A-za-z]+(\\|[A-za-z]+)*\\)\\$$": {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+    };
+    typed_string_array_type: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            minItems: {
+                type: string;
+                minimum: number;
+            };
+            maxItems: {
+                type: string;
+                minimum: number;
+            };
+            items: {
+                oneOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    required?: undefined;
+                    additionalProperties?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    required: string[];
+                    additionalProperties: boolean;
+                    properties: {
+                        oneOf: {
+                            type: string;
+                            minItems: number;
+                            uniqueItems: boolean;
+                            items: {
+                                $ref: string;
+                            };
+                        };
+                    };
+                    $ref?: undefined;
+                })[];
+            };
+        };
+    };
+    typed_string_prefixItems_type: {
+        type: string;
+        required: string[];
+        additionalProperties: boolean;
+        properties: {
+            items: {
+                type: string;
+                const: boolean;
+            };
+            minItems: {
+                type: string;
+                minimum: number;
+            };
+            maxItems: {
+                type: string;
+                minimum: number;
+            };
+            prefixItems: {
+                type: string;
+                minItems: number;
+                items: {
+                    $ref: string;
+                };
+            };
+        };
+    };
+    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 class TypedString {
+    private already_configured;
+    private static _instance?;
+    protected constructor();
+    configure_ajv($defs: {
+        [key: string]: SchemaObject;
+    }, ajv: Ajv): void;
+    static instance(): TypedString;
+}
+export {};

package/lib/CustomParsingTypes/TypedString.js

@@ -0,0 +1,204 @@
+import { local_ref, } from '../StringStartsWith';
+import { UnrealEngineString_parent_schema, UnrealEngineString_schema_definitions, } from './UnrealEngineString';
+import { typed_string_const_schema, } from './TypedStringConst';
+import { ValueToRegexFormatter, } from './ValueToRegexFormatter';
+import { typed_string_enum_schema, } from './TypedStringEnum';
+import { typed_string_pattern_general_schema_self_testing, } from './TypedStringPattern';
+const property_regex = '^[A-Za-z][A-Za-z0-9_\\[\\]]*$';
+export const pattern_properties_regex = '^\\^\\([A-za-z]+(\\|[A-za-z]+)*\\)\\$$';
+export const pattern_properties_schema = {
+    type: 'object',
+    required: [
+        'minProperties',
+        'patternProperties',
+    ],
+    additionalProperties: false,
+    properties: {
+        minProperties: { type: 'number', minimum: 1 },
+        patternProperties: {
+            type: 'object',
+            additionalProperties: false,
+            minProperties: 1,
+            maxProperties: 1,
+            patternProperties: {
+                [pattern_properties_regex]: {
+                    $ref: '#/$defs/typed_string_subtypes',
+                },
+            },
+        },
+    },
+};
+export function generate_object_parent_schema() {
+    return { $ref: '#/$defs/typed_string_parent_type' };
+}
+export function generate_typed_string_$defs($defs) {
+    return {
+        ...UnrealEngineString_schema_definitions,
+        typed_string_subtypes: {
+            oneOf: [
+                {
+                    type: 'object',
+                    required: ['$ref'],
+                    additionalProperties: false,
+                    properties: {
+                        $ref: {
+                            type: 'string',
+                            enum: $defs,
+                        },
+                    },
+                },
+                UnrealEngineString_parent_schema,
+                typed_string_const_schema,
+                typed_string_enum_schema,
+                typed_string_pattern_general_schema_self_testing,
+                { $ref: '#/$defs/typed_string_parent_type' },
+            ],
+        },
+        typed_string_parent_type: {
+            type: 'object',
+            required: ['type', 'minLength', 'typed_string'],
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', const: 'string' },
+                minLength: { type: 'number', const: 1 },
+                typed_string: {
+                    oneOf: [
+                        { $ref: '#/$defs/typed_string_object_type' },
+                        { $ref: `#/$defs/typed_string_object_pattern_type` },
+                        { $ref: '#/$defs/typed_string_array_type' },
+                        { $ref: '#/$defs/typed_string_prefixItems_type' },
+                    ],
+                },
+            },
+        },
+        typed_string_object_type: {
+            type: 'object',
+            required: [
+                'properties',
+            ],
+            additionalProperties: false,
+            properties: {
+                required: {
+                    type: 'array',
+                    minItems: 1,
+                    items: {
+                        type: 'string',
+                        minLength: 1,
+                    },
+                },
+                properties: {
+                    type: 'object',
+                    additionalProperties: false,
+                    patternProperties: {
+                        [property_regex]: {
+                            $ref: '#/$defs/typed_string_subtypes',
+                        },
+                    },
+                },
+            },
+        },
+        typed_string_object_pattern_type: pattern_properties_schema,
+        typed_string_array_type: {
+            type: 'object',
+            required: [
+                'minItems',
+                'items',
+            ],
+            additionalProperties: false,
+            properties: {
+                minItems: {
+                    type: 'number',
+                    'minimum': 0,
+                },
+                maxItems: {
+                    type: 'number',
+                    'minimum': 1,
+                },
+                items: {
+                    oneOf: [
+                        { $ref: '#/$defs/typed_string_subtypes' },
+                        {
+                            type: 'object',
+                            required: ['oneOf'],
+                            additionalProperties: false,
+                            properties: {
+                                oneOf: {
+                                    type: 'array',
+                                    minItems: 1,
+                                    uniqueItems: true,
+                                    items: {
+                                        $ref: `#/$defs/typed_string_subtypes`,
+                                    },
+                                },
+                            },
+                        },
+                        { $ref: '#/$defs/typed_string_prefixItems_type' },
+                    ],
+                },
+            },
+        },
+        typed_string_prefixItems_type: {
+            type: 'object',
+            required: [
+                'minItems',
+                'items',
+                'prefixItems',
+            ],
+            additionalProperties: false,
+            properties: {
+                items: { type: 'boolean', const: false },
+                minItems: {
+                    type: 'number',
+                    'minimum': 0,
+                },
+                maxItems: {
+                    type: 'number',
+                    'minimum': 1,
+                },
+                prefixItems: {
+                    type: 'array',
+                    minItems: 1,
+                    items: { $ref: '#/$defs/typed_string_subtypes' },
+                },
+            },
+        },
+    };
+}
+export class TypedString {
+    already_configured = new WeakSet();
+    static _instance;
+    constructor() {
+    }
+    configure_ajv($defs, ajv) {
+        if (this.already_configured.has(ajv)) {
+            return;
+        }
+        const local_refs = Object.keys($defs).map(local_ref);
+        this.already_configured.add(ajv);
+        const meta_schema = {
+            $defs: generate_typed_string_$defs(local_refs),
+            oneOf: [
+                { $ref: '#/$defs/typed_string_object_type' },
+                { $ref: '#/$defs/typed_string_object_pattern_type' },
+                { $ref: '#/$defs/typed_string_array_type' },
+                { $ref: '#/$defs/typed_string_prefixItems_type' },
+            ],
+        };
+        const formatter = new ValueToRegexFormatter($defs);
+        ajv.addKeyword({
+            keyword: 'typed_string',
+            type: 'string',
+            metaSchema: meta_schema,
+            macro: (schema) => {
+                return formatter.pattern_from_value(schema);
+            },
+        });
+    }
+    static instance() {
+        if (!this._instance) {
+            this._instance = new this();
+        }
+        return this._instance;
+    }
+}
+//# sourceMappingURL=TypedString.js.map

package/lib/CustomParsingTypes/TypedStringConst.d.ts

@@ -0,0 +1,28 @@
+import { SupportedSubSchemaType } from './CustomPairingTypes';
+export declare const typed_string_const_value_regex = "^(?:[A-Za-z0-9][A-Za-z0-9_ -]*|/(?:[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 declare const typed_string_const_value_regex__native: RegExp;
+export declare const typed_string_const_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        const: {
+            type: string;
+            pattern: string;
+        };
+    };
+};
+export type const_schema_type = {
+    type: 'string';
+    const: string;
+};
+declare class TypedStringConst extends SupportedSubSchemaType<const_schema_type> {
+    is_supported_schema(maybe: unknown): maybe is const_schema_type;
+    value_regex(value: const_schema_type): string;
+}
+export declare const typed_string_const: TypedStringConst;
+export {};

package/lib/CustomParsingTypes/TypedStringConst.js

@@ -0,0 +1,35 @@
+import { UnrealEngineString_general_regex, } from './UnrealEngineString';
+import { object_has_property, SupportedSubSchemaType, value_is_non_array_object, } from './CustomPairingTypes';
+import { is_string, } from '../StringStartsWith';
+export const typed_string_const_value_regex = `^(?:[A-Za-z0-9][A-Za-z0-9_ -]*|${UnrealEngineString_general_regex}|\\(\\))$`;
+export const typed_string_const_value_regex__native = new RegExp(typed_string_const_value_regex);
+export const typed_string_const_schema = {
+    type: 'object',
+    required: ['type', 'const'],
+    additionalProperties: false,
+    properties: {
+        type: { type: 'string', const: 'string' },
+        const: {
+            type: 'string',
+            pattern: typed_string_const_value_regex,
+        },
+    },
+};
+class TypedStringConst 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_property(maybe, 'const', is_string)
+            && typed_string_const_value_regex__native.test(maybe.const));
+    }
+    value_regex(value) {
+        const lazy_escape = value.const
+            .replace(/\(/g, '\\(')
+            .replace(/\)/g, '\\)');
+        return `(?:(${lazy_escape}|"${lazy_escape}"))`;
+    }
+}
+export const typed_string_const = new TypedStringConst();
+//# sourceMappingURL=TypedStringConst.js.map

package/lib/CustomParsingTypes/TypedStringEnum.d.ts

@@ -0,0 +1,30 @@
+import { SupportedSubSchemaType } from './CustomPairingTypes';
+export type enum_schema_type = {
+    type: 'string';
+    enum: [string, ...string[]];
+};
+export declare const typed_string_enum_schema: {
+    type: string;
+    required: string[];
+    additionalProperties: boolean;
+    properties: {
+        type: {
+            type: string;
+            const: string;
+        };
+        enum: {
+            type: string;
+            minItems: number;
+            items: {
+                type: string;
+                pattern: string;
+            };
+        };
+    };
+};
+declare class TypedStringEnum extends SupportedSubSchemaType<enum_schema_type> {
+    is_supported_schema(maybe: unknown): maybe is enum_schema_type;
+    value_regex(value: enum_schema_type): string;
+}
+export declare const typed_string_enum: TypedStringEnum;
+export {};