vscode-json-languageservice 5.6.2 → 5.6.4

package/lib/esm/services/schemas/draft-2020-12-flat.js

@@ -0,0 +1,295 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// This file is generated - do not edit directly!
+// Derived from https://json-schema.org/draft/2020-12
+export default {
+    $id: 'https://json-schema.org/draft/2020-12/schema',
+    $schema: 'https://json-schema.org/draft/2020-12/schema',
+    title: '(Flattened static) Core and Validation specifications meta-schema',
+    type: [
+        'object',
+        'boolean',
+    ],
+    properties: {
+        definitions: {
+            $comment: 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
+            type: 'object',
+            additionalProperties: {
+                $ref: '#',
+            },
+            default: {},
+        },
+        dependencies: {
+            $comment: '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+            type: 'object',
+            additionalProperties: {
+                anyOf: [
+                    {
+                        $ref: '#',
+                    },
+                    {
+                        $ref: '#/$defs/stringArray',
+                    },
+                ],
+            },
+        },
+        $id: {
+            type: 'string',
+            format: 'uri-reference',
+            $comment: 'Non-empty fragments not allowed.',
+            pattern: '^[^#]*#?$',
+        },
+        $schema: {
+            type: 'string',
+            format: 'uri',
+        },
+        $anchor: {
+            type: 'string',
+            pattern: '^[A-Za-z_][-A-Za-z0-9._]*$',
+        },
+        $ref: {
+            type: 'string',
+            format: 'uri-reference',
+        },
+        $dynamicRef: {
+            type: 'string',
+            format: 'uri-reference',
+        },
+        $vocabulary: {
+            type: 'object',
+            propertyNames: {
+                type: 'string',
+                format: 'uri',
+            },
+            additionalProperties: {
+                type: 'boolean',
+            },
+        },
+        $comment: {
+            type: 'string',
+        },
+        $defs: {
+            type: 'object',
+            additionalProperties: {
+                $ref: '#',
+            },
+            default: {},
+        },
+        prefixItems: {
+            $ref: '#/$defs/schemaArray',
+        },
+        items: {
+            $ref: '#',
+        },
+        contains: {
+            $ref: '#',
+        },
+        additionalProperties: {
+            $ref: '#',
+        },
+        properties: {
+            type: 'object',
+            additionalProperties: {
+                $ref: '#',
+            },
+            default: {},
+        },
+        patternProperties: {
+            type: 'object',
+            additionalProperties: {
+                $ref: '#',
+            },
+            propertyNames: {
+                format: 'regex',
+            },
+            default: {},
+        },
+        dependentSchemas: {
+            type: 'object',
+            additionalProperties: {
+                $ref: '#',
+            },
+        },
+        propertyNames: {
+            $ref: '#',
+        },
+        if: {
+            $ref: '#',
+        },
+        then: {
+            $ref: '#',
+        },
+        else: {
+            $ref: '#',
+        },
+        allOf: {
+            $ref: '#/$defs/schemaArray',
+        },
+        anyOf: {
+            $ref: '#/$defs/schemaArray',
+        },
+        oneOf: {
+            $ref: '#/$defs/schemaArray',
+        },
+        not: {
+            $ref: '#',
+        },
+        unevaluatedItems: {
+            $ref: '#',
+        },
+        unevaluatedProperties: {
+            $ref: '#',
+        },
+        multipleOf: {
+            type: 'number',
+            exclusiveMinimum: 0,
+        },
+        maximum: {
+            type: 'number',
+        },
+        exclusiveMaximum: {
+            type: 'number',
+        },
+        minimum: {
+            type: 'number',
+        },
+        exclusiveMinimum: {
+            type: 'number',
+        },
+        maxLength: {
+            $ref: '#/$defs/nonNegativeInteger',
+        },
+        minLength: {
+            $ref: '#/$defs/nonNegativeIntegerDefault0',
+        },
+        pattern: {
+            type: 'string',
+            format: 'regex',
+        },
+        maxItems: {
+            $ref: '#/$defs/nonNegativeInteger',
+        },
+        minItems: {
+            $ref: '#/$defs/nonNegativeIntegerDefault0',
+        },
+        uniqueItems: {
+            type: 'boolean',
+            default: false,
+        },
+        maxContains: {
+            $ref: '#/$defs/nonNegativeInteger',
+        },
+        minContains: {
+            $ref: '#/$defs/nonNegativeInteger',
+            default: 1,
+        },
+        maxProperties: {
+            $ref: '#/$defs/nonNegativeInteger',
+        },
+        minProperties: {
+            $ref: '#/$defs/nonNegativeIntegerDefault0',
+        },
+        required: {
+            $ref: '#/$defs/stringArray',
+        },
+        dependentRequired: {
+            type: 'object',
+            additionalProperties: {
+                $ref: '#/$defs/stringArray',
+            },
+        },
+        const: true,
+        enum: {
+            type: 'array',
+            items: true,
+        },
+        type: {
+            anyOf: [
+                {
+                    $ref: '#/$defs/simpleTypes',
+                },
+                {
+                    type: 'array',
+                    items: {
+                        $ref: '#/$defs/simpleTypes',
+                    },
+                    minItems: 1,
+                    uniqueItems: true,
+                },
+            ],
+        },
+        title: {
+            type: 'string',
+        },
+        description: {
+            type: 'string',
+        },
+        default: true,
+        deprecated: {
+            type: 'boolean',
+            default: false,
+        },
+        readOnly: {
+            type: 'boolean',
+            default: false,
+        },
+        writeOnly: {
+            type: 'boolean',
+            default: false,
+        },
+        examples: {
+            type: 'array',
+            items: true,
+        },
+        format: {
+            type: 'string',
+        },
+        contentMediaType: {
+            type: 'string',
+        },
+        contentEncoding: {
+            type: 'string',
+        },
+        contentSchema: {
+            $ref: '#',
+        },
+    },
+    $defs: {
+        schemaArray: {
+            type: 'array',
+            minItems: 1,
+            items: {
+                $ref: '#',
+            },
+        },
+        nonNegativeInteger: {
+            type: 'integer',
+            minimum: 0,
+        },
+        nonNegativeIntegerDefault0: {
+            $ref: '#/$defs/nonNegativeInteger',
+            default: 0,
+        },
+        simpleTypes: {
+            enum: [
+                'array',
+                'boolean',
+                'integer',
+                'null',
+                'number',
+                'object',
+                'string',
+            ],
+        },
+        stringArray: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+            uniqueItems: true,
+            default: [],
+        },
+    },
+};

package/lib/umd/parser/jsonParser.js

@@ -394,9 +394,10 @@
             }
             const testAlternatives = (alternatives, maxOneMatch) => {
                 const matches = [];
+                const alternativesToTest = _tryDiscriminatorOptimization(alternatives) ?? alternatives;
                 // remember the best match that is used for error messages
                 let bestMatch = undefined;
-                for (const subSchemaRef of alternatives) {
+                for (const subSchemaRef of alternativesToTest) {
                     const subSchema = asSchema(subSchemaRef);
                     const subValidationResult = new ValidationResult();
                     const subMatchingSchemas = matchingSchemas.newSub();
@@ -521,6 +522,70 @@
                 });
             }
         }
+        function _tryDiscriminatorOptimization(alternatives) {
+            if (alternatives.length < 2) {
+                return undefined;
+            }
+            const buildConstMap = (getSchemas) => {
+                const constMap = new Map();
+                for (let i = 0; i < alternatives.length; i++) {
+                    const schemas = getSchemas(asSchema(alternatives[i]), i);
+                    if (!schemas) {
+                        return undefined; // Early exit if any alternative can't be processed
+                    }
+                    schemas.forEach(([key, schema]) => {
+                        if (schema.const !== undefined) {
+                            if (!constMap.has(key)) {
+                                constMap.set(key, new Map());
+                            }
+                            const valueMap = constMap.get(key);
+                            if (!valueMap.has(schema.const)) {
+                                valueMap.set(schema.const, []);
+                            }
+                            valueMap.get(schema.const).push(i);
+                        }
+                    });
+                }
+                return constMap;
+            };
+            const findDiscriminator = (constMap, getValue) => {
+                for (const [key, valueMap] of constMap) {
+                    const coveredAlts = new Set();
+                    valueMap.forEach(indices => indices.forEach(idx => coveredAlts.add(idx)));
+                    if (coveredAlts.size === alternatives.length) {
+                        const discriminatorValue = getValue(key);
+                        const matchingIndices = valueMap.get(discriminatorValue);
+                        if (matchingIndices?.length) {
+                            return matchingIndices.map(idx => alternatives[idx]);
+                        }
+                        break; // Found valid discriminator but no match
+                    }
+                }
+                return undefined;
+            };
+            if (node.type === 'object' && node.properties?.length) {
+                const constMap = buildConstMap((schema) => schema.properties ? Object.entries(schema.properties).map(([k, v]) => [k, asSchema(v)]) : undefined);
+                if (constMap) {
+                    return findDiscriminator(constMap, (propName) => {
+                        const prop = node.properties.find(p => p.keyNode.value === propName);
+                        return prop?.valueNode?.type === 'string' ? prop.valueNode.value : undefined;
+                    });
+                }
+            }
+            else if (node.type === 'array' && node.items?.length) {
+                const constMap = buildConstMap((schema) => {
+                    const itemSchemas = schema.prefixItems || (Array.isArray(schema.items) ? schema.items : undefined);
+                    return itemSchemas ? itemSchemas.map((item, idx) => [idx, asSchema(item)]) : undefined;
+                });
+                if (constMap) {
+                    return findDiscriminator(constMap, (itemIndex) => {
+                        const item = node.items[itemIndex];
+                        return item?.type === 'string' ? item.value : undefined;
+                    });
+                }
+            }
+            return undefined;
+        }
         function _validateNumberNode(node) {
             const val = node.value;
             function normalizeFloats(float) {
@@ -982,7 +1047,7 @@
                 for (const f of node.properties) {
                     const key = f.keyNode;
                     if (key) {
-                        validate(key, propertyNames, validationResult, NoOpSchemaCollector.instance, context);
+                        validate(key, propertyNames, validationResult, matchingSchemas, context);
                     }
                 }
             }

package/lib/umd/services/configuration.js

@@ -8,12 +8,14 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "@vscode/l10n"], factory);
+        define(["require", "exports", "./schemas/draft-2019-09-flat", "./schemas/draft-2020-12-flat", "@vscode/l10n"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.schemaContributions = void 0;
+    const draft_2019_09_flat_1 = require("./schemas/draft-2019-09-flat");
+    const draft_2020_12_flat_1 = require("./schemas/draft-2020-12-flat");
     const l10n = require("@vscode/l10n");
     exports.schemaContributions = {
         schemaAssociations: [],
@@ -465,7 +467,9 @@
                     'not': { '$ref': '#' }
                 },
                 'default': true
-            }
+            },
+            'https://json-schema.org/draft/2020-12/schema': draft_2020_12_flat_1.default,
+            'https://json-schema.org/draft/2019-09/schema': draft_2019_09_flat_1.default
         }
     };
     const descriptions = {

package/lib/umd/services/jsonHover.js

@@ -56,60 +56,60 @@
                 }
             }
             return this.schemaService.getSchemaForResource(document.uri, doc).then((schema) => {
-                if (schema && node) {
-                    const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset);
-                    let title = undefined;
-                    let markdownDescription = undefined;
-                    let markdownEnumValueDescription = undefined, enumValue = undefined;
-                    matchingSchemas.every((s) => {
-                        if (s.node === node && !s.inverted && s.schema) {
-                            title = title || s.schema.title;
-                            markdownDescription = markdownDescription || s.schema.markdownDescription || toMarkdown(s.schema.description);
-                            if (s.schema.enum) {
-                                const idx = s.schema.enum.indexOf(Parser.getNodeValue(node));
-                                if (s.schema.markdownEnumDescriptions) {
-                                    markdownEnumValueDescription = s.schema.markdownEnumDescriptions[idx];
-                                }
-                                else if (s.schema.enumDescriptions) {
-                                    markdownEnumValueDescription = toMarkdown(s.schema.enumDescriptions[idx]);
-                                }
-                                if (markdownEnumValueDescription) {
-                                    enumValue = s.schema.enum[idx];
-                                    if (typeof enumValue !== 'string') {
-                                        enumValue = JSON.stringify(enumValue);
-                                    }
-                                }
+                if (!schema) {
+                    return null;
+                }
+                let title = undefined;
+                let markdownDescription = undefined;
+                let markdownEnumValueDescription = undefined, enumValue = undefined;
+                const matchingSchemas = doc.getMatchingSchemas(schema.schema, node.offset).filter((s) => s.node === node && !s.inverted).map((s) => s.schema);
+                for (const schema of matchingSchemas) {
+                    title = title || schema.title;
+                    markdownDescription = markdownDescription || schema.markdownDescription || toMarkdown(schema.description);
+                    if (schema.enum) {
+                        const idx = schema.enum.indexOf(Parser.getNodeValue(node));
+                        if (schema.markdownEnumDescriptions) {
+                            markdownEnumValueDescription = schema.markdownEnumDescriptions[idx];
+                        }
+                        else if (schema.enumDescriptions) {
+                            markdownEnumValueDescription = toMarkdown(schema.enumDescriptions[idx]);
+                        }
+                        if (markdownEnumValueDescription) {
+                            enumValue = schema.enum[idx];
+                            if (typeof enumValue !== 'string') {
+                                enumValue = JSON.stringify(enumValue);
                             }
                         }
-                        return true;
-                    });
-                    let result = '';
-                    if (title) {
-                        result = toMarkdown(title);
                     }
-                    if (markdownDescription) {
-                        if (result.length > 0) {
-                            result += "\n\n";
-                        }
-                        result += markdownDescription;
+                }
+                let result = '';
+                if (title) {
+                    result = toMarkdown(title);
+                }
+                if (markdownDescription) {
+                    if (result.length > 0) {
+                        result += "\n\n";
                     }
-                    if (markdownEnumValueDescription) {
-                        if (result.length > 0) {
-                            result += "\n\n";
-                        }
-                        result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
+                    result += markdownDescription;
+                }
+                if (markdownEnumValueDescription) {
+                    if (result.length > 0) {
+                        result += "\n\n";
                     }
-                    return createHover([result]);
+                    result += `\`${toMarkdownCodeBlock(enumValue)}\`: ${markdownEnumValueDescription}`;
                 }
-                return null;
+                return createHover([result]);
             });
         }
     }
     exports.JSONHover = JSONHover;
     function toMarkdown(plain) {
         if (plain) {
-            const res = plain.replace(/([^\n\r])(\r?\n)([^\n\r])/gm, '$1\n\n$3'); // single new lines to \n\n (Markdown paragraph)
-            return res.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&"); // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
+            return plain
+                .trim()
+                .replace(/[\\`*_{}[\]()<>#+\-.!]/g, '\\$&') // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
+                .replace(/([ \t]+)/g, (_match, g1) => '&nbsp;'.repeat(g1.length)) // escape spaces tabs
+                .replace(/\n/g, '\\\n'); // escape new lines
         }
         return undefined;
     }