vscode-json-languageservice 5.7.2 → 6.0.0-next.2

package/lib/esm/services/jsonSelectionRanges.js

@@ -2,7 +2,7 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { Range, SelectionRange } from '../jsonLanguageTypes';
+import { Range, SelectionRange } from '../jsonLanguageTypes.js';
 import { createScanner } from 'jsonc-parser';
 export function getSelectionRanges(document, positions, doc) {
     function getSelectionRange(position) {

package/lib/esm/services/jsonValidation.js

@@ -2,9 +2,9 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-import { ErrorCode, Diagnostic, DiagnosticSeverity, Range } from '../jsonLanguageTypes';
+import { ErrorCode, Diagnostic, DiagnosticSeverity, Range } from '../jsonLanguageTypes.js';
 import * as l10n from '@vscode/l10n';
-import { isBoolean } from '../utils/objects';
+import { isBoolean } from '../utils/objects.js';
 export class JSONValidation {
     constructor(jsonSchemaService, promiseConstructor) {
         this.jsonSchemaService = jsonSchemaService;
@@ -60,7 +60,7 @@ export class JSONValidation {
                     for (const warning of schema.warnings) {
                         addSchemaProblem(warning.message, warning.code, warning.relatedInformation);
                     }
-                    const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft);
+                    const semanticErrors = jsonDocument.validate(textDocument, schema.schema, schemaValidation, documentSettings?.schemaDraft, schema.activeVocabularies);
                     if (semanticErrors) {
                         semanticErrors.forEach(addProblem);
                     }
@@ -90,7 +90,7 @@ export class JSONValidation {
             return diagnostics;
         };
         if (schema) {
-            const uri = schema.id || ('schemaservice://untitled/' + idCounter++);
+            const uri = schema.$id || schema.id || ('schemaservice://untitled/' + idCounter++);
             const handle = this.jsonSchemaService.registerExternalSchema({ uri, schema });
             return handle.getResolvedSchema().then(resolvedSchema => {
                 return getDiagnostics(resolvedSchema);

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

@@ -271,7 +271,7 @@ declare const _default: {
                 type: string;
             };
             uniqueItems: boolean;
-            default: any[];
+            default: never[];
         };
     };
 };

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

@@ -269,7 +269,7 @@ declare const _default: {
                 type: string;
             };
             uniqueItems: boolean;
-            default: any[];
+            default: never[];
         };
     };
 };

package/lib/esm/services/vocabularies.js

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { SchemaDraft } from '../jsonLanguageTypes.js';
+const CORE_201909 = 'https://json-schema.org/draft/2019-09/vocab/core';
+const CORE_202012 = 'https://json-schema.org/draft/2020-12/vocab/core';
+const vocabularyKeywords = {
+    [CORE_201909]: [
+        '$id', '$schema', '$ref', '$anchor', '$recursiveRef',
+        '$recursiveAnchor', '$defs', '$comment', '$vocabulary'
+    ],
+    'https://json-schema.org/draft/2019-09/vocab/applicator': [
+        'prefixItems', 'items', 'contains', 'additionalProperties',
+        'properties', 'patternProperties', 'dependentSchemas',
+        'propertyNames', 'if', 'then', 'else', 'allOf', 'anyOf', 'oneOf', 'not'
+    ],
+    'https://json-schema.org/draft/2019-09/vocab/validation': [
+        'type', 'enum', 'const', 'multipleOf', 'maximum', 'exclusiveMaximum',
+        'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern',
+        'maxItems', 'minItems', 'uniqueItems', 'maxContains', 'minContains',
+        'maxProperties', 'minProperties', 'required', 'dependentRequired'
+    ],
+    'https://json-schema.org/draft/2019-09/vocab/meta-data': [
+        'title', 'description', 'default', 'deprecated',
+        'readOnly', 'writeOnly', 'examples'
+    ],
+    'https://json-schema.org/draft/2019-09/vocab/format': [
+        'format'
+    ],
+    'https://json-schema.org/draft/2019-09/vocab/content': [
+        'contentEncoding', 'contentMediaType', 'contentSchema'
+    ],
+    [CORE_202012]: [
+        '$id', '$schema', '$ref', '$anchor', '$dynamicRef',
+        '$dynamicAnchor', '$defs', '$comment', '$vocabulary'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/applicator': [
+        'prefixItems', 'items', 'contains', 'additionalProperties',
+        'properties', 'patternProperties', 'dependentSchemas',
+        'propertyNames', 'if', 'then', 'else', 'allOf', 'anyOf', 'oneOf', 'not'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/unevaluated': [
+        'unevaluatedItems', 'unevaluatedProperties'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/validation': [
+        'type', 'enum', 'const', 'multipleOf', 'maximum', 'exclusiveMaximum',
+        'minimum', 'exclusiveMinimum', 'maxLength', 'minLength', 'pattern',
+        'maxItems', 'minItems', 'uniqueItems', 'maxContains', 'minContains',
+        'maxProperties', 'minProperties', 'required', 'dependentRequired'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/meta-data': [
+        'title', 'description', 'default', 'deprecated',
+        'readOnly', 'writeOnly', 'examples'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/format-annotation': [
+        'format'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/format-assertion': [
+        'format'
+    ],
+    'https://json-schema.org/draft/2020-12/vocab/content': [
+        'contentEncoding', 'contentMediaType', 'contentSchema'
+    ]
+};
+/*
+ * Checks if a keyword is enabled based on the active vocabularies.
+ * If no vocabulary constraints are present, all keywords are enabled.
+ * Core keywords are always enabled regardless of vocabulary settings.
+ *
+ * @param keyword The keyword to check (e.g., 'type', 'properties', '$ref')
+ * @param activeVocabularies Set of active vocabulary URIs, or undefined if no constraints
+ * @returns true if the keyword should be processed, false otherwise
+ */
+export function isKeywordEnabled(keyword, activeVocabularies) {
+    // If no vocabulary constraints, treat all keywords as enabled
+    if (!activeVocabularies) {
+        return true;
+    }
+    // Check if this keyword belongs to any active vocabulary
+    for (const [vocabUri, keywords] of Object.entries(vocabularyKeywords)) {
+        if (keywords.includes(keyword) && activeVocabularies.has(vocabUri)) {
+            return true;
+        }
+    }
+    // Core keywords are always enabled per JSON Schema spec.
+    // Check both 2019-09 and 2020-12 core vocabularies.
+    if (vocabularyKeywords[CORE_201909].includes(keyword) ||
+        vocabularyKeywords[CORE_202012].includes(keyword)) {
+        return true;
+    }
+    // Keyword not found in any vocabulary - disable it
+    return false;
+}
+/*
+ * Checks if format validation should produce assertion errors.
+ *
+ * According to JSON Schema 2020-12:
+ * - format-annotation: format is purely informational, no validation errors
+ * - format-assertion: format must be validated and can produce errors
+ *
+ * For backwards compatibility:
+ * - If no vocabularies are specified and no explicit 2019-09+ draft, format asserts
+ * - 2019-09 format vocabulary asserts when required, annotation-only when optional
+ * - 2020-12 format-assertion vocabulary asserts
+ * - 2020-12 format-annotation vocabulary does not assert
+ *
+ * @param activeVocabularies Map of active vocabulary URIs to required flag, or undefined if no constraints
+ * @param schemaDraft The explicitly declared schema draft (only set when $schema was present), or undefined
+ * @returns true if format validation should produce errors, false if annotation-only
+ */
+export function isFormatAssertionEnabled(activeVocabularies, schemaDraft) {
+    // If vocabulary constraints are present, use them to determine format assertion
+    if (activeVocabularies && activeVocabularies.size > 0) {
+        // 2020-12 format-assertion explicitly enables format validation errors
+        if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-assertion')) {
+            return true;
+        }
+        // 2019-09 uses the format vocabulary value to control assertions:
+        // true enables assertion, false leaves format as annotation-only.
+        const format201909 = activeVocabularies.get('https://json-schema.org/draft/2019-09/vocab/format');
+        if (format201909 !== undefined) {
+            return format201909;
+        }
+        // 2020-12 format-annotation is annotation-only, no assertion
+        if (activeVocabularies.has('https://json-schema.org/draft/2020-12/vocab/format-annotation')) {
+            return false;
+        }
+        // No format vocabulary active - no assertion
+        return false;
+    }
+    // No vocabulary constraints:
+    // For explicitly declared 2019-09+ schemas, format is annotation-only by default per spec.
+    // For older drafts or no explicit $schema, format asserts for backward compatibility.
+    if (schemaDraft !== undefined && schemaDraft >= SchemaDraft.v2019_09) {
+        return false;
+    }
+    return true;
+}

package/lib/esm/utils/format.js

@@ -1,5 +1,5 @@
 import { format as formatJSON } from 'jsonc-parser';
-import { Range, TextEdit } from '../jsonLanguageTypes';
+import { Range, TextEdit } from '../jsonLanguageTypes.js';
 export function format(documentToFormat, formattingOptions, formattingRange) {
     let range = undefined;
     if (formattingRange) {

package/lib/esm/utils/sort.js

@@ -3,9 +3,9 @@
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
 import { createScanner } from 'jsonc-parser';
-import { TextDocument, TextEdit, Position, Range } from '../jsonLanguageTypes';
-import { format } from './format';
-import { PropertyTree, Container } from './propertyTree';
+import { TextDocument, TextEdit, Position, Range } from '../jsonLanguageTypes.js';
+import { format } from './format.js';
+import { PropertyTree, Container } from './propertyTree.js';
 export function sort(documentToSort, formattingOptions) {
     const options = {
         ...formattingOptions,

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "vscode-json-languageservice",
-  "version": "5.7.2",
+  "version": "6.0.0-next.2",
   "description": "Language service for JSON",
-  "main": "./lib/umd/jsonLanguageService.js",
-  "typings": "./lib/umd/jsonLanguageService",
-  "module": "./lib/esm/jsonLanguageService.js",
+  "type": "module",
+  "types": "./lib/esm/jsonLanguageService.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/esm/jsonLanguageService.d.ts",
+      "import": "./lib/esm/jsonLanguageService.js"
+    }
+  },
   "author": "Microsoft Corporation",
   "repository": {
     "type": "git",
@@ -15,36 +20,34 @@
     "url": "https://github.com/Microsoft/vscode-json-languageservice"
   },
   "devDependencies": {
-    "@types/mocha": "^10.0.10",
-    "@types/node": "22.x",
-    "@typescript-eslint/eslint-plugin": "^8.56.0",
-    "@typescript-eslint/parser": "^8.56.0",
-    "eslint": "^9.39.3",
-    "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite.git#69acf52990b004240839ae19b4bec8fb01d50876",
-    "mocha": "^11.7.5",
+    "@types/node": "^22.20.1",
+    "@typescript-eslint/eslint-plugin": "^8.63.0",
+    "@typescript-eslint/parser": "^8.63.0",
+    "eslint": "10.6.0",
+    "json-schema-test-suite": "https://github.com/json-schema-org/JSON-Schema-Test-Suite.git#92acb61eb772a932c077d5ffa634ded719d2d738",
     "rimraf": "^6.1.3",
-    "typescript": "^5.9.3"
+    "typescript": "6.0.x"
   },
   "dependencies": {
-    "jsonc-parser": "^3.3.1",
+    "@vscode/l10n": "^0.0.18",
+    "jsonc-parser": "4.0.0-next.1",
     "vscode-languageserver-textdocument": "^1.0.12",
-    "vscode-languageserver-types": "^3.17.5",
-    "vscode-uri": "^3.1.0",
-    "@vscode/l10n": "^0.0.18"
+    "vscode-languageserver-types": "^3.18.0",
+    "vscode-uri": "^3.1.0"
   },
   "scripts": {
-    "prepack": "npm run clean && npm run compile-esm && npm run test && npm run remove-sourcemap-refs",
+    "prepack": "npm run clean && npm run compile && npm run test && npm run remove-sourcemap-refs",
     "compile": "tsc -p ./src",
-    "compile-esm": "tsc -p ./src/tsconfig.esm.json",
     "clean": "rimraf lib",
+    "bundle-schemas": "node ./build/bundle-schemas.js",
     "remove-sourcemap-refs": "node ./build/remove-sourcemap-refs.js",
     "watch": "tsc -w -p ./src",
     "pretest": "npm run compile",
-    "test": "mocha",
+    "test": "node --test ./lib/esm/test/*.test.js",
     "posttest": "npm run lint",
     "coverage": "npx nyc -r lcov npm run test",
     "lint": "eslint src/**/*.ts",
     "install-types-next": "npm install vscode-languageserver-types@next -f -S && npm install vscode-languageserver-textdocument@next -f -S",
-    "sample": "npm run compile && node ./lib/umd/example/sample.js"
+    "sample": "npm run compile && node ./lib/esm/example/sample.js"
   }
 }

package/lib/umd/jsonContributions.d.ts

@@ -1,21 +0,0 @@
-import { MarkedString, CompletionItem } from './jsonLanguageService';
-export interface JSONWorkerContribution {
-    getInfoContribution(uri: string, location: JSONPath): PromiseLike<MarkedString[]>;
-    collectPropertyCompletions(uri: string, location: JSONPath, currentWord: string, addValue: boolean, isLast: boolean, result: CompletionsCollector): PromiseLike<any>;
-    collectValueCompletions(uri: string, location: JSONPath, propertyKey: string, result: CompletionsCollector): PromiseLike<any>;
-    collectDefaultCompletions(uri: string, result: CompletionsCollector): PromiseLike<any>;
-    resolveCompletion?(item: CompletionItem): PromiseLike<CompletionItem>;
-}
-export type Segment = string | number;
-export type JSONPath = Segment[];
-export type JSONCompletionItem = CompletionItem & {
-    insertText: string;
-};
-export interface CompletionsCollector {
-    add(suggestion: JSONCompletionItem & {
-        insertText: string;
-    }): void;
-    error(message: string): void;
-    setAsIncomplete(): void;
-    getNumberOfProposals(): number;
-}

package/lib/umd/jsonContributions.js

@@ -1,12 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-});

package/lib/umd/jsonLanguageService.d.ts

@@ -1,30 +0,0 @@
-import { ASTNode, Color, ColorInformation, ColorPresentation, LanguageServiceParams, LanguageSettings, DocumentLanguageSettings, FoldingRange, JSONSchema, SelectionRange, FoldingRangesContext, DocumentSymbolsContext, ColorInformationContext as DocumentColorsContext, TextDocument, Position, CompletionItem, CompletionList, Hover, Range, SymbolInformation, Diagnostic, TextEdit, FormattingOptions, DocumentSymbol, DefinitionLink, MatchingSchema, JSONLanguageStatus, SortOptions } from './jsonLanguageTypes';
-import { DocumentLink } from 'vscode-languageserver-types';
-export type JSONDocument = {
-    root: ASTNode | undefined;
-    getNodeFromOffset(offset: number, includeRightBound?: boolean): ASTNode | undefined;
-};
-export * from './jsonLanguageTypes';
-export interface LanguageService {
-    configure(settings: LanguageSettings): void;
-    doValidation(document: TextDocument, jsonDocument: JSONDocument, documentSettings?: DocumentLanguageSettings, schema?: JSONSchema): PromiseLike<Diagnostic[]>;
-    parseJSONDocument(document: TextDocument): JSONDocument;
-    newJSONDocument(rootNode: ASTNode | undefined, syntaxDiagnostics?: Diagnostic[], comments?: Range[]): JSONDocument;
-    resetSchema(uri: string): boolean;
-    getMatchingSchemas(document: TextDocument, jsonDocument: JSONDocument, schema?: JSONSchema): PromiseLike<MatchingSchema[]>;
-    getLanguageStatus(document: TextDocument, jsonDocument: JSONDocument): JSONLanguageStatus;
-    doResolve(item: CompletionItem): PromiseLike<CompletionItem>;
-    doComplete(document: TextDocument, position: Position, doc: JSONDocument): PromiseLike<CompletionList | null>;
-    findDocumentSymbols(document: TextDocument, doc: JSONDocument, context?: DocumentSymbolsContext): SymbolInformation[];
-    findDocumentSymbols2(document: TextDocument, doc: JSONDocument, context?: DocumentSymbolsContext): DocumentSymbol[];
-    findDocumentColors(document: TextDocument, doc: JSONDocument, context?: DocumentColorsContext): PromiseLike<ColorInformation[]>;
-    getColorPresentations(document: TextDocument, doc: JSONDocument, color: Color, range: Range): ColorPresentation[];
-    doHover(document: TextDocument, position: Position, doc: JSONDocument): PromiseLike<Hover | null>;
-    getFoldingRanges(document: TextDocument, context?: FoldingRangesContext): FoldingRange[];
-    getSelectionRanges(document: TextDocument, positions: Position[], doc: JSONDocument): SelectionRange[];
-    findDefinition(document: TextDocument, position: Position, doc: JSONDocument): PromiseLike<DefinitionLink[]>;
-    findLinks(document: TextDocument, doc: JSONDocument): PromiseLike<DocumentLink[]>;
-    format(document: TextDocument, range: Range | undefined, options: FormattingOptions): TextEdit[];
-    sort(document: TextDocument, options: SortOptions): TextEdit[];
-}
-export declare function getLanguageService(params: LanguageServiceParams): LanguageService;

package/lib/umd/jsonLanguageService.js

@@ -1,79 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./services/jsonCompletion", "./services/jsonHover", "./services/jsonValidation", "./services/jsonDocumentSymbols", "./parser/jsonParser", "./services/configuration", "./services/jsonSchemaService", "./services/jsonFolding", "./services/jsonSelectionRanges", "./utils/sort", "./utils/format", "./services/jsonLinks", "./jsonLanguageTypes"], factory);
-    }
-})(function (require, exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.getLanguageService = getLanguageService;
-    const jsonCompletion_1 = require("./services/jsonCompletion");
-    const jsonHover_1 = require("./services/jsonHover");
-    const jsonValidation_1 = require("./services/jsonValidation");
-    const jsonDocumentSymbols_1 = require("./services/jsonDocumentSymbols");
-    const jsonParser_1 = require("./parser/jsonParser");
-    const configuration_1 = require("./services/configuration");
-    const jsonSchemaService_1 = require("./services/jsonSchemaService");
-    const jsonFolding_1 = require("./services/jsonFolding");
-    const jsonSelectionRanges_1 = require("./services/jsonSelectionRanges");
-    const sort_1 = require("./utils/sort");
-    const format_1 = require("./utils/format");
-    const jsonLinks_1 = require("./services/jsonLinks");
-    __exportStar(require("./jsonLanguageTypes"), exports);
-    function getLanguageService(params) {
-        const promise = params.promiseConstructor || Promise;
-        const jsonSchemaService = new jsonSchemaService_1.JSONSchemaService(params.schemaRequestService, params.workspaceContext, promise);
-        jsonSchemaService.setSchemaContributions(configuration_1.schemaContributions);
-        const jsonCompletion = new jsonCompletion_1.JSONCompletion(jsonSchemaService, params.contributions, promise, params.clientCapabilities);
-        const jsonHover = new jsonHover_1.JSONHover(jsonSchemaService, params.contributions, promise);
-        const jsonDocumentSymbols = new jsonDocumentSymbols_1.JSONDocumentSymbols(jsonSchemaService);
-        const jsonValidation = new jsonValidation_1.JSONValidation(jsonSchemaService, promise);
-        return {
-            configure: (settings) => {
-                jsonSchemaService.clearExternalSchemas();
-                settings.schemas?.forEach(jsonSchemaService.registerExternalSchema.bind(jsonSchemaService));
-                jsonValidation.configure(settings);
-            },
-            resetSchema: (uri) => jsonSchemaService.onResourceChange(uri),
-            doValidation: jsonValidation.doValidation.bind(jsonValidation),
-            getLanguageStatus: jsonValidation.getLanguageStatus.bind(jsonValidation),
-            parseJSONDocument: (document) => (0, jsonParser_1.parse)(document, { collectComments: true }),
-            newJSONDocument: (root, diagnostics, comments) => (0, jsonParser_1.newJSONDocument)(root, diagnostics, comments),
-            getMatchingSchemas: jsonSchemaService.getMatchingSchemas.bind(jsonSchemaService),
-            doResolve: jsonCompletion.doResolve.bind(jsonCompletion),
-            doComplete: jsonCompletion.doComplete.bind(jsonCompletion),
-            findDocumentSymbols: jsonDocumentSymbols.findDocumentSymbols.bind(jsonDocumentSymbols),
-            findDocumentSymbols2: jsonDocumentSymbols.findDocumentSymbols2.bind(jsonDocumentSymbols),
-            findDocumentColors: jsonDocumentSymbols.findDocumentColors.bind(jsonDocumentSymbols),
-            getColorPresentations: jsonDocumentSymbols.getColorPresentations.bind(jsonDocumentSymbols),
-            doHover: jsonHover.doHover.bind(jsonHover),
-            getFoldingRanges: jsonFolding_1.getFoldingRanges,
-            getSelectionRanges: jsonSelectionRanges_1.getSelectionRanges,
-            findDefinition: () => Promise.resolve([]),
-            findLinks: jsonLinks_1.findLinks,
-            format: (document, range, options) => (0, format_1.format)(document, options, range),
-            sort: (document, options) => (0, sort_1.sort)(document, options)
-        };
-    }
-});