@lakutata/core 1.0.60 → 3.0.0-beta.1

package/dist/cjs/lib/validation/engine/json-schema/parsers/json.d.ts

@@ -0,0 +1,245 @@
+import type { Definitions, SpecCondition, SpecDependency, SpecRule, SchemaSpec, JsonSchema, LogicalOpParserFn, ParserOptions } from '../model.js';
+/**
+ * A numeric bound
+ */
+interface Bound {
+    value: number;
+    exclusive: boolean;
+}
+/**
+ * Converts schema descriptions into JSON schemas (draft 07)
+ */
+export declare class JsonSchemaParser {
+    $schema: string | undefined;
+    includeSchemaDialect: boolean;
+    childrenFieldName: string;
+    optionsFieldName: string;
+    ruleArgFieldName: string;
+    enumFieldName: string;
+    allowUnknownFlagName: string;
+    inheritedPreferences: Record<string, unknown>[];
+    logicalOpParser: Record<string, LogicalOpParserFn | null | undefined>;
+    knownKeys: string[] | undefined;
+    protected _exact: boolean;
+    protected readonly _inexactSchemas: WeakSet<JsonSchema>;
+    constructor(opts?: ParserOptions);
+    parse(spec: SchemaSpec, definitions?: Definitions, level?: number): JsonSchema;
+    /**
+     * Whether a converted schema is exact: it accepts the values the schema accepts (without conversion), and only
+     * them (lakutata's own). Formats are named after the rules, and the numbers beyond the safe integers are accepted.
+     * @param schema
+     */
+    isExact(schema: JsonSchema): boolean;
+    /**
+     * Marks the schema being converted as not exact: something of it has no JSON Schema equivalent and is dropped
+     */
+    protected _inexact(): void;
+    protected _parse(spec: SchemaSpec, definitions: Definitions, level: number): JsonSchema;
+    protected _retainKnownKeys(schema: JsonSchema): JsonSchema;
+    /**
+     * Marks the schemas with constructs JSON Schema cannot express as not exact (the constructs the type setters do
+     * not convert)
+     * @param spec
+     */
+    protected _checkRules(spec: SchemaSpec): void;
+    protected _pushInheritiedPreferences(spec: SchemaSpec): boolean;
+    protected _popInheritiedPreferences(): void;
+    protected _getInheritedPreferences(): Record<string, unknown>;
+    /**
+     * The preferences of a schema: its preferences merged with the inherited ones (upstream uses its preferences
+     * instead of the inherited ones)
+     * @param spec
+     */
+    protected _getPreferences(spec: SchemaSpec): Record<string, unknown>;
+    protected _isIfThenElseSupported(): boolean;
+    protected _getChildrenFieldName(): string;
+    protected _getOptionsFieldName(): string;
+    protected _getRuleArgFieldName(): string;
+    protected _getEnumFieldName(): string;
+    protected _getAllowUnknownFlagName(): string;
+    protected _getLocalSchemaBasePath(): string;
+    protected _getFieldDescription(fieldDefn: SchemaSpec): unknown;
+    protected _getFieldType(fieldDefn: SchemaSpec): string | undefined;
+    /**
+     * Makes a schema with a null type nullable (OpenAPI 3.0), and replaces the type lists where types are lists
+     * @param _fieldSchema
+     * @param _fieldDefn
+     */
+    protected _addNullTypeIfNullable(_fieldSchema: JsonSchema, _fieldDefn: SchemaSpec): void;
+    protected _getFieldExample(fieldDefn: SchemaSpec): unknown;
+    protected _getPresence(fieldDefn: SchemaSpec): unknown;
+    protected _isRequired(fieldDefn: SchemaSpec): boolean;
+    protected _getDefaultValue(fieldDefn: SchemaSpec): unknown;
+    /**
+     * Whether the unknown keys of an object are accepted (true), rejected (false), or must match a schema
+     * @param spec
+     */
+    protected _getUnknown(spec: SchemaSpec): boolean | SchemaSpec;
+    /**
+     * Whether the unknown keys of an object are stripped before its rules
+     * @param spec
+     */
+    protected _stripsUnknown(spec: SchemaSpec): boolean;
+    /**
+     * Whether the items of arrays which match no item schema are stripped
+     * @param spec
+     */
+    protected _stripsArrayItems(spec: SchemaSpec): boolean;
+    protected _setIfNotEmpty(schema: JsonSchema, field: string, value: unknown): void;
+    /**
+     * The tighter of a bound and a limit (a reference limit is dropped)
+     * @param bound
+     * @param limit
+     * @param exclusive
+     * @param lower
+     */
+    protected _bound(bound: Bound | undefined, limit: unknown, exclusive: boolean, lower: boolean): Bound | undefined;
+    /**
+     * Adds a keyword, or a subschema of the keyword to allOf when the schema has the keyword (lakutata)
+     * @param schema
+     * @param keyword
+     * @param value
+     */
+    protected _addKeyword(schema: JsonSchema, keyword: string, value: unknown): void;
+    /**
+     * Merges the keywords of a subschema, or adds the subschema to allOf when the keywords conflict (lakutata)
+     * @param schema
+     * @param part
+     */
+    protected _mergeKeywords(schema: JsonSchema, part: JsonSchema): void;
+    protected _setBasicProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    /**
+     * The schema of a values list (only these values)
+     * @param values
+     */
+    protected _getValuesSchema(values: unknown[]): JsonSchema;
+    /**
+     * Applies the valid and invalid values of a schema description (lakutata's own; upstream sets the enum of the
+     * valid values, and adds null to the type): the valid values of `valid()` are the only accepted values, the
+     * values of `allow()` are accepted besides the values of the schema, and the invalid values are rejected
+     * @param schema
+     * @param spec
+     */
+    protected _setValues(schema: JsonSchema, spec: SchemaSpec): JsonSchema;
+    /**
+     * Arrays accepting single values also accept a value their items accept (lakutata's own)
+     * @param schema
+     * @param spec
+     */
+    protected _setSingle(schema: JsonSchema, spec: SchemaSpec): JsonSchema;
+    /**
+     * Whether a string schema certainly accepts the empty string
+     * @param schema
+     */
+    protected _acceptsEmpty(schema: JsonSchema): boolean;
+    /**
+     * Whether a string schema certainly rejects the empty string
+     * @param schema
+     */
+    protected _rejectsEmpty(schema: JsonSchema): boolean;
+    /**
+     * Whether null can be accepted by adding it to the type of a schema: its keywords apply to other types
+     * @param schema
+     */
+    protected _canAddType(schema: JsonSchema): boolean;
+    protected _setBinaryFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    /**
+     * The format of binary strings (JSON Schema has none: upstream sets binary)
+     */
+    protected _getBinaryFormat(): string | undefined;
+    protected _setObjectProperties(schema: JsonSchema, spec: SchemaSpec, definitions: Definitions, level: number): void;
+    /**
+     * Sets the schema of the key names
+     * @param schema
+     * @param names
+     */
+    protected _setPropertyNames(schema: JsonSchema, names: JsonSchema): void;
+    /**
+     * Sets the patternProperties of the patterns of an object (lakutata's own; upstream also adds each pattern as a
+     * property): like the engine, a pattern applies to the keys which are not defined keys and which no previous
+     * pattern (without fallthrough) matched. Returns false when a pattern is not expressible.
+     * @param schema
+     * @param spec
+     * @param definedKeys
+     * @param definitions
+     * @param level
+     */
+    protected _setPatternProperties(schema: JsonSchema, spec: SchemaSpec, definedKeys: string[], definitions: Definitions, level: number): boolean;
+    /**
+     * The schema of the key names an object processes (its defined keys and the keys its patterns match)
+     * @param spec
+     */
+    protected _knownKeys(spec: SchemaSpec): JsonSchema;
+    /**
+     * Whether a key is processed by an object (not stripped as an unknown key)
+     * @param spec
+     * @param key
+     */
+    protected _isKnownKey(spec: SchemaSpec, key: string): boolean;
+    protected _setObjectDependencies(schema: JsonSchema, spec: SchemaSpec): void;
+    protected _setDependencySubSchema(schema: JsonSchema, dependency: SpecDependency): JsonSchema;
+    /**
+     * The format of a number schema (JSON Schema has no number formats)
+     * @param _rules
+     */
+    protected _getNumberFormat(_rules: SpecRule[]): string | undefined;
+    protected _setNumberFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    protected _setStringFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    /**
+     * Sets the schema the items of an array contain
+     * @param schema
+     * @param contains
+     * @param options
+     */
+    protected _setContains(schema: JsonSchema, contains: JsonSchema, options: {
+        min?: number;
+        max?: number;
+    }): void;
+    /**
+     * Sets the items of an array with ordered items
+     * @param schema
+     * @param ordered
+     * @param rest the schema of the other items (undefined: no other items)
+     */
+    protected _setTuple(schema: JsonSchema, ordered: JsonSchema[], rest: JsonSchema | undefined): void;
+    protected _setArrayFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec, definitions: Definitions, level: number): void;
+    protected _setDateFieldProperties(fieldSchema: JsonSchema, fieldDefn: SchemaSpec): void;
+    protected _setAlternativesProperties(schema: JsonSchema, spec: SchemaSpec, definitions: Definitions, level: number): void;
+    protected _setConditionProperties(schema: JsonSchema, spec: SchemaSpec, definitions: Definitions, level: number, conditionFieldName: string, logicKeyword?: string): void;
+    protected _setConditionSchema(ifThenStyle: boolean, schema: JsonSchema, conditionSpec: SpecCondition, definitions: Definitions, level: number): JsonSchema | undefined;
+    protected _parseIfThenElseCondition(schema: JsonSchema, conditionSpec: SpecCondition, definitions: Definitions, level: number): JsonSchema;
+    /**
+     * Sets the branches of a condition which cannot be converted: a value matches one of them (lakutata's own)
+     * @param schema
+     * @param conditionSpec
+     * @param definitions
+     * @param level
+     */
+    protected _setBranches(schema: JsonSchema, conditionSpec: SpecCondition, definitions: Definitions, level: number): JsonSchema;
+    protected _parseSwitchCondition(ifThenStyle: boolean, schema: JsonSchema, condition: SpecCondition, definitions: Definitions, level: number): void;
+    protected _setConditionCompositionStyle(schema: JsonSchema, condition: SpecCondition, definitions: Definitions, level: number): JsonSchema;
+    protected _setAnyProperties(schema: JsonSchema): void;
+    /**
+     * The schemas the value must also match (lakutata)
+     * @param schema
+     * @param spec
+     * @param definitions
+     * @param level
+     */
+    protected _setAllOf(schema: JsonSchema, spec: SchemaSpec, definitions: Definitions, level: number): void;
+    /**
+     * No JSON value is a function or a symbol (lakutata)
+     * @param schema
+     * @param spec
+     */
+    protected _setNonJsonProperties(schema: JsonSchema, spec: SchemaSpec): void;
+    protected _setMetaProperties(schema: JsonSchema, spec: SchemaSpec): void;
+    protected _setLinkFieldProperties(schema: JsonSchema, spec: SchemaSpec): void;
+    protected _copyMetasToSchema(spec: SchemaSpec, schema: JsonSchema): void;
+    /**
+     * Intended to be overridden by child parsers. By default no meta key will be is considered "known".
+     * @param _key
+     */
+    protected _isKnownMetaKey(_key: string): boolean;
+}
+export {};