vscode-json-languageservice 5.6.2 → 5.6.4

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 5.6.0 / 2025-05-28
 ================
- * added `Schema.enumSortTexts`and  `Schema.enumDetails` to control the sort order and presentation of suggestions for enaums
+ * added `Schema.enumSortTexts` and `Schema.enumDetails` to control the sort order and presentation of suggestions for enums
 
 5.5.0 / 2025-03-25
 ================

package/lib/esm/parser/jsonParser.js

@@ -364,9 +364,10 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
         }
         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();
@@ -491,6 +492,70 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             });
         }
     }
+    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) {
@@ -952,7 +1017,7 @@ function validate(n, schema, validationResult, matchingSchemas, context) {
             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/esm/services/configuration.js

@@ -2,6 +2,8 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
+import draft201909Flat from './schemas/draft-2019-09-flat';
+import draft202012Flat from './schemas/draft-2020-12-flat';
 import * as l10n from '@vscode/l10n';
 export const schemaContributions = {
     schemaAssociations: [],
@@ -453,7 +455,9 @@ export const schemaContributions = {
                 'not': { '$ref': '#' }
             },
             'default': true
-        }
+        },
+        'https://json-schema.org/draft/2020-12/schema': draft202012Flat,
+        'https://json-schema.org/draft/2019-09/schema': draft201909Flat
     }
 };
 const descriptions = {

package/lib/esm/services/jsonHover.js

@@ -44,59 +44,59 @@ export class JSONHover {
             }
         }
         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]);
         });
     }
 }
 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;
 }

package/lib/esm/services/schemas/draft-2019-09-flat.d.ts

@@ -0,0 +1,278 @@
+declare const _default: {
+    $id: string;
+    $schema: string;
+    title: string;
+    type: string[];
+    properties: {
+        definitions: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        dependencies: {
+            $comment: string;
+            type: string;
+            additionalProperties: {
+                anyOf: {
+                    $ref: string;
+                }[];
+            };
+        };
+        $id: {
+            type: string;
+            format: string;
+            $comment: string;
+            pattern: string;
+        };
+        $schema: {
+            type: string;
+            format: string;
+        };
+        $anchor: {
+            type: string;
+            pattern: string;
+        };
+        $ref: {
+            type: string;
+            format: string;
+        };
+        $recursiveAnchor: {
+            type: string;
+            default: boolean;
+        };
+        $vocabulary: {
+            type: string;
+            propertyNames: {
+                type: string;
+                format: string;
+            };
+            additionalProperties: {
+                type: string;
+            };
+        };
+        $comment: {
+            type: string;
+        };
+        $defs: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        additionalItems: {
+            $ref: string;
+        };
+        unevaluatedItems: {
+            $ref: string;
+        };
+        items: {
+            anyOf: {
+                $ref: string;
+            }[];
+        };
+        contains: {
+            $ref: string;
+        };
+        additionalProperties: {
+            $ref: string;
+        };
+        unevaluatedProperties: {
+            $ref: string;
+        };
+        properties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        patternProperties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            propertyNames: {
+                format: string;
+            };
+            default: {};
+        };
+        dependentSchemas: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+        };
+        propertyNames: {
+            $ref: string;
+        };
+        if: {
+            $ref: string;
+        };
+        then: {
+            $ref: string;
+        };
+        else: {
+            $ref: string;
+        };
+        allOf: {
+            $ref: string;
+        };
+        anyOf: {
+            $ref: string;
+        };
+        oneOf: {
+            $ref: string;
+        };
+        not: {
+            $ref: string;
+        };
+        multipleOf: {
+            type: string;
+            exclusiveMinimum: number;
+        };
+        maximum: {
+            type: string;
+        };
+        exclusiveMaximum: {
+            type: string;
+        };
+        minimum: {
+            type: string;
+        };
+        exclusiveMinimum: {
+            type: string;
+        };
+        maxLength: {
+            $ref: string;
+        };
+        minLength: {
+            $ref: string;
+        };
+        pattern: {
+            type: string;
+            format: string;
+        };
+        maxItems: {
+            $ref: string;
+        };
+        minItems: {
+            $ref: string;
+        };
+        uniqueItems: {
+            type: string;
+            default: boolean;
+        };
+        maxContains: {
+            $ref: string;
+        };
+        minContains: {
+            $ref: string;
+            default: number;
+        };
+        maxProperties: {
+            $ref: string;
+        };
+        minProperties: {
+            $ref: string;
+        };
+        required: {
+            $ref: string;
+        };
+        dependentRequired: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+        };
+        const: boolean;
+        enum: {
+            type: string;
+            items: boolean;
+        };
+        type: {
+            anyOf: ({
+                $ref: string;
+                type?: undefined;
+                items?: undefined;
+                minItems?: undefined;
+                uniqueItems?: undefined;
+            } | {
+                type: string;
+                items: {
+                    $ref: string;
+                };
+                minItems: number;
+                uniqueItems: boolean;
+                $ref?: undefined;
+            })[];
+        };
+        title: {
+            type: string;
+        };
+        description: {
+            type: string;
+        };
+        default: boolean;
+        deprecated: {
+            type: string;
+            default: boolean;
+        };
+        readOnly: {
+            type: string;
+            default: boolean;
+        };
+        writeOnly: {
+            type: string;
+            default: boolean;
+        };
+        examples: {
+            type: string;
+            items: boolean;
+        };
+        format: {
+            type: string;
+        };
+        contentMediaType: {
+            type: string;
+        };
+        contentEncoding: {
+            type: string;
+        };
+        contentSchema: {
+            $ref: string;
+        };
+    };
+    $defs: {
+        schemaArray: {
+            type: string;
+            minItems: number;
+            items: {
+                $ref: string;
+            };
+        };
+        nonNegativeInteger: {
+            type: string;
+            minimum: number;
+        };
+        nonNegativeIntegerDefault0: {
+            $ref: string;
+            default: number;
+        };
+        simpleTypes: {
+            enum: string[];
+        };
+        stringArray: {
+            type: string;
+            items: {
+                type: string;
+            };
+            uniqueItems: boolean;
+            default: any[];
+        };
+    };
+};
+export default _default;