@volar/language-core 2.4.11 → 2.4.13

package/index.d.ts

@@ -1,9 +1,9 @@
 export { Mapping, SourceMap } from '@volar/source-map';
-export * from './lib/editorFeatures';
+export * from './lib/editor';
 export * from './lib/linkedCodeMap';
 export * from './lib/types';
 export * from './lib/utils';
 import type { Language, LanguagePlugin, MapperFactory, SourceScript, VirtualCode } from './lib/types';
 export declare const defaultMapperFactory: MapperFactory;
-export declare function createLanguage<T>(plugins: LanguagePlugin<T>[], scriptRegistry: Map<T, SourceScript<T>>, sync: (id: T, includeFsFiles: boolean, shouldRegister: boolean) => void): Language<T>;
+export declare function createLanguage<T>(plugins: LanguagePlugin<T>[], scriptRegistry: Map<T, SourceScript<T>>, sync: (id: T, includeFsFiles: boolean, shouldRegister: boolean) => void, onAssociationDirty?: (targetId: T) => void): Language<T>;
 export declare function forEachEmbeddedCode(virtualCode: VirtualCode): Generator<VirtualCode>;

package/index.js

@@ -19,7 +19,7 @@ exports.createLanguage = createLanguage;
 exports.forEachEmbeddedCode = forEachEmbeddedCode;
 var source_map_1 = require("@volar/source-map");
 Object.defineProperty(exports, "SourceMap", { enumerable: true, get: function () { return source_map_1.SourceMap; } });
-__exportStar(require("./lib/editorFeatures"), exports);
+__exportStar(require("./lib/editor"), exports);
 __exportStar(require("./lib/linkedCodeMap"), exports);
 __exportStar(require("./lib/types"), exports);
 __exportStar(require("./lib/utils"), exports);
@@ -27,7 +27,7 @@ const source_map_2 = require("@volar/source-map");
 const linkedCodeMap_1 = require("./lib/linkedCodeMap");
 const defaultMapperFactory = mappings => new source_map_2.SourceMap(mappings);
 exports.defaultMapperFactory = defaultMapperFactory;
-function createLanguage(plugins, scriptRegistry, sync) {
+function createLanguage(plugins, scriptRegistry, sync, onAssociationDirty) {
     const virtualCodeToSourceScriptMap = new WeakMap();
     const virtualCodeToSourceMap = new WeakMap();
     const virtualCodeToLinkedCodeMap = new WeakMap();
@@ -71,14 +71,20 @@ function createLanguage(plugins, scriptRegistry, sync) {
                     const sourceScript = scriptRegistry.get(id);
                     if (sourceScript.languageId !== languageId || sourceScript.associatedOnly !== associatedOnly) {
                         this.delete(id);
+                        triggerTargetsDirty(sourceScript);
                         return this.set(id, snapshot, languageId);
                     }
                     else if (associatedOnly) {
-                        sourceScript.snapshot = snapshot;
+                        if (sourceScript.snapshot !== snapshot) {
+                            sourceScript.snapshot = snapshot;
+                            triggerTargetsDirty(sourceScript);
+                        }
                     }
                     else if (sourceScript.isAssociationDirty || sourceScript.snapshot !== snapshot) {
-                        // snapshot updated
-                        sourceScript.snapshot = snapshot;
+                        if (sourceScript.snapshot !== snapshot) {
+                            sourceScript.snapshot = snapshot;
+                            triggerTargetsDirty(sourceScript);
+                        }
                         const codegenCtx = prepareCreateVirtualCode(sourceScript);
                         if (sourceScript.generated) {
                             const { updateVirtualCode, createVirtualCode } = sourceScript.generated.languagePlugin;
@@ -99,7 +105,6 @@ function createLanguage(plugins, scriptRegistry, sync) {
                                 return;
                             }
                         }
-                        triggerTargetsDirty(sourceScript);
                     }
                     else {
                         // not changed
@@ -200,6 +205,7 @@ function createLanguage(plugins, scriptRegistry, sync) {
             const sourceScript = scriptRegistry.get(id);
             if (sourceScript) {
                 sourceScript.isAssociationDirty = true;
+                onAssociationDirty?.(sourceScript.id);
             }
         });
     }

package/lib/editor.d.ts

@@ -0,0 +1,34 @@
+import type { CodeInformation, Mapper } from './types';
+export declare function isHoverEnabled(info: CodeInformation): boolean;
+export declare function isInlayHintsEnabled(info: CodeInformation): boolean;
+export declare function isCodeLensEnabled(info: CodeInformation): boolean;
+export declare function isMonikerEnabled(info: CodeInformation): boolean;
+export declare function isInlineValueEnabled(info: CodeInformation): boolean;
+export declare function isSemanticTokensEnabled(info: CodeInformation): boolean;
+export declare function isCallHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isTypeHierarchyEnabled(info: CodeInformation): boolean;
+export declare function isRenameEnabled(info: CodeInformation): boolean;
+export declare function isDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isTypeDefinitionEnabled(info: CodeInformation): boolean;
+export declare function isReferencesEnabled(info: CodeInformation): boolean;
+export declare function isImplementationEnabled(info: CodeInformation): boolean;
+export declare function isHighlightEnabled(info: CodeInformation): boolean;
+export declare function isSymbolsEnabled(info: CodeInformation): boolean;
+export declare function isFoldingRangesEnabled(info: CodeInformation): boolean;
+export declare function isSelectionRangesEnabled(info: CodeInformation): boolean;
+export declare function isLinkedEditingEnabled(info: CodeInformation): boolean;
+export declare function isColorEnabled(info: CodeInformation): boolean;
+export declare function isDocumentLinkEnabled(info: CodeInformation): boolean;
+export declare function isDiagnosticsEnabled(info: CodeInformation): boolean;
+export declare function isCodeActionsEnabled(info: CodeInformation): boolean;
+export declare function isFormattingEnabled(info: CodeInformation): boolean;
+export declare function isCompletionEnabled(info: CodeInformation): boolean;
+export declare function isAutoInsertEnabled(info: CodeInformation): boolean;
+export declare function isSignatureHelpEnabled(info: CodeInformation): boolean;
+export declare function shouldReportDiagnostics(info: CodeInformation, source: string | undefined, code: string | number | undefined): boolean;
+export declare function resolveRenameNewName(newName: string, info: CodeInformation): string;
+export declare function resolveRenameEditText(text: string, info: CodeInformation): string;
+export declare function findOverlapCodeRange(start: number, end: number, map: Mapper, filter: (data: CodeInformation) => boolean): {
+    start: number;
+    end: number;
+} | undefined;

package/lib/editor.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHoverEnabled = isHoverEnabled;
+exports.isInlayHintsEnabled = isInlayHintsEnabled;
+exports.isCodeLensEnabled = isCodeLensEnabled;
+exports.isMonikerEnabled = isMonikerEnabled;
+exports.isInlineValueEnabled = isInlineValueEnabled;
+exports.isSemanticTokensEnabled = isSemanticTokensEnabled;
+exports.isCallHierarchyEnabled = isCallHierarchyEnabled;
+exports.isTypeHierarchyEnabled = isTypeHierarchyEnabled;
+exports.isRenameEnabled = isRenameEnabled;
+exports.isDefinitionEnabled = isDefinitionEnabled;
+exports.isTypeDefinitionEnabled = isTypeDefinitionEnabled;
+exports.isReferencesEnabled = isReferencesEnabled;
+exports.isImplementationEnabled = isImplementationEnabled;
+exports.isHighlightEnabled = isHighlightEnabled;
+exports.isSymbolsEnabled = isSymbolsEnabled;
+exports.isFoldingRangesEnabled = isFoldingRangesEnabled;
+exports.isSelectionRangesEnabled = isSelectionRangesEnabled;
+exports.isLinkedEditingEnabled = isLinkedEditingEnabled;
+exports.isColorEnabled = isColorEnabled;
+exports.isDocumentLinkEnabled = isDocumentLinkEnabled;
+exports.isDiagnosticsEnabled = isDiagnosticsEnabled;
+exports.isCodeActionsEnabled = isCodeActionsEnabled;
+exports.isFormattingEnabled = isFormattingEnabled;
+exports.isCompletionEnabled = isCompletionEnabled;
+exports.isAutoInsertEnabled = isAutoInsertEnabled;
+exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
+exports.shouldReportDiagnostics = shouldReportDiagnostics;
+exports.resolveRenameNewName = resolveRenameNewName;
+exports.resolveRenameEditText = resolveRenameEditText;
+exports.findOverlapCodeRange = findOverlapCodeRange;
+function isHoverEnabled(info) {
+    return !!info.semantic;
+}
+function isInlayHintsEnabled(info) {
+    return !!info.semantic;
+}
+function isCodeLensEnabled(info) {
+    return !!info.semantic;
+}
+function isMonikerEnabled(info) {
+    return !!info.semantic;
+}
+function isInlineValueEnabled(info) {
+    return !!info.semantic;
+}
+function isSemanticTokensEnabled(info) {
+    return typeof info.semantic === 'object'
+        ? info.semantic.shouldHighlight?.() ?? true
+        : !!info.semantic;
+}
+function isCallHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeHierarchyEnabled(info) {
+    return !!info.navigation;
+}
+function isRenameEnabled(info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.shouldRename?.() ?? true
+        : !!info.navigation;
+}
+function isDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isTypeDefinitionEnabled(info) {
+    return !!info.navigation;
+}
+function isReferencesEnabled(info) {
+    return !!info.navigation;
+}
+function isImplementationEnabled(info) {
+    return !!info.navigation;
+}
+function isHighlightEnabled(info) {
+    return !!info.navigation;
+}
+function isSymbolsEnabled(info) {
+    return !!info.structure;
+}
+function isFoldingRangesEnabled(info) {
+    return !!info.structure;
+}
+function isSelectionRangesEnabled(info) {
+    return !!info.structure;
+}
+function isLinkedEditingEnabled(info) {
+    return !!info.structure;
+}
+function isColorEnabled(info) {
+    return !!info.structure;
+}
+function isDocumentLinkEnabled(info) {
+    return !!info.structure;
+}
+function isDiagnosticsEnabled(info) {
+    return !!info.verification;
+}
+function isCodeActionsEnabled(info) {
+    return !!info.verification;
+}
+function isFormattingEnabled(info) {
+    return !!info.format;
+}
+function isCompletionEnabled(info) {
+    return !!info.completion;
+}
+function isAutoInsertEnabled(info) {
+    return !!info.completion;
+}
+function isSignatureHelpEnabled(info) {
+    return !!info.completion;
+}
+// should...
+function shouldReportDiagnostics(info, source, code) {
+    return typeof info.verification === 'object'
+        ? info.verification.shouldReport?.(source, code) ?? true
+        : !!info.verification;
+}
+//  resolve...
+function resolveRenameNewName(newName, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameNewName?.(newName) ?? newName
+        : newName;
+}
+function resolveRenameEditText(text, info) {
+    return typeof info.navigation === 'object'
+        ? info.navigation.resolveRenameEditText?.(text) ?? text
+        : text;
+}
+function findOverlapCodeRange(start, end, map, filter) {
+    let mappedStart;
+    let mappedEnd;
+    for (const [mapped, mapping] of map.toGeneratedLocation(start)) {
+        if (filter(mapping.data)) {
+            mappedStart = mapped;
+            break;
+        }
+    }
+    for (const [mapped, mapping] of map.toGeneratedLocation(end)) {
+        if (filter(mapping.data)) {
+            mappedEnd = mapped;
+            break;
+        }
+    }
+    if (mappedStart === undefined || mappedEnd === undefined) {
+        for (const mapping of map.mappings) {
+            if (filter(mapping.data)) {
+                const mappingStart = mapping.sourceOffsets[0];
+                const mappingEnd = mapping.sourceOffsets[mapping.sourceOffsets.length - 1] + mapping.lengths[mapping.lengths.length - 1];
+                const overlap = getOverlapRange(start, end, mappingStart, mappingEnd);
+                if (overlap) {
+                    const curMappedStart = (overlap.start - mappingStart) + mapping.generatedOffsets[0];
+                    const lastGeneratedLength = (mapping.generatedLengths ?? mapping.lengths)[mapping.generatedOffsets.length - 1];
+                    const curMappedEndOffset = Math.min(overlap.end - mapping.sourceOffsets[mapping.sourceOffsets.length - 1], lastGeneratedLength);
+                    const curMappedEnd = mapping.generatedOffsets[mapping.generatedOffsets.length - 1] + curMappedEndOffset;
+                    mappedStart = mappedStart === undefined ? curMappedStart : Math.min(mappedStart, curMappedStart);
+                    mappedEnd = mappedEnd === undefined ? curMappedEnd : Math.max(mappedEnd, curMappedEnd);
+                }
+            }
+        }
+    }
+    if (mappedStart !== undefined && mappedEnd !== undefined) {
+        return {
+            start: mappedStart,
+            end: mappedEnd,
+        };
+    }
+}
+function getOverlapRange(range1Start, range1End, range2Start, range2End) {
+    const start = Math.max(range1Start, range2Start);
+    const end = Math.min(range1End, range2End);
+    if (start > end) {
+        return undefined;
+    }
+    return {
+        start,
+        end,
+    };
+}
+//# sourceMappingURL=editor.js.map

package/lib/editorFeatures.d.ts

@@ -26,5 +26,3 @@ export declare function isCompletionEnabled(info: CodeInformation): boolean;
 export declare function isAutoInsertEnabled(info: CodeInformation): boolean;
 export declare function isSignatureHelpEnabled(info: CodeInformation): boolean;
 export declare function shouldReportDiagnostics(info: CodeInformation, source: string | undefined, code: string | number | undefined): boolean;
-export declare function resolveRenameNewName(newName: string, info: CodeInformation): string;
-export declare function resolveRenameEditText(text: string, info: CodeInformation): string;

package/lib/editorFeatures.js

@@ -27,8 +27,6 @@ exports.isCompletionEnabled = isCompletionEnabled;
 exports.isAutoInsertEnabled = isAutoInsertEnabled;
 exports.isSignatureHelpEnabled = isSignatureHelpEnabled;
 exports.shouldReportDiagnostics = shouldReportDiagnostics;
-exports.resolveRenameNewName = resolveRenameNewName;
-exports.resolveRenameEditText = resolveRenameEditText;
 function isHoverEnabled(info) {
     return !!info.semantic;
 }
@@ -117,15 +115,4 @@ function shouldReportDiagnostics(info, source, code) {
         ? info.verification.shouldReport?.(source, code) ?? true
         : !!info.verification;
 }
-//  resolve...
-function resolveRenameNewName(newName, info) {
-    return typeof info.navigation === 'object'
-        ? info.navigation.resolveRenameNewName?.(newName) ?? newName
-        : newName;
-}
-function resolveRenameEditText(text, info) {
-    return typeof info.navigation === 'object'
-        ? info.navigation.resolveRenameEditText?.(text) ?? text
-        : text;
-}
 //# sourceMappingURL=editorFeatures.js.map

package/lib/types.d.ts

@@ -49,9 +49,27 @@ export interface VirtualCode {
     embeddedCodes?: VirtualCode[];
     linkedCodeMappings?: Mapping[];
 }
+/**
+ * CodeInformation is a configuration object attached to each CodeMapping (between source code and generated code,
+ * e.g. between the template code in a .vue file and the type-checkable TS code generated from it) that
+ * determines what code/language features are expected to be available for the mapping.
+ *
+ * Due to the dynamic nature of code generation and the fact that, for example, things like Code Actions
+ * and auto-complete shouldn't be triggerable on certain "in-between" regions of generated code, we need
+ * a way to shut off certain features in certain regions, while leaving them enabled in others.
+ */
 export interface CodeInformation {
-    /** virtual code is expected to support verification */
+    /** virtual code is expected to support verification, where verification includes:
+     *
+     * - diagnostics (syntactic, semantic, and others, such as those generated by the TypeScript language service on generated TS code)
+     * - code actions (refactorings, quick fixes,etc.)
+     */
     verification?: boolean | {
+        /**
+         * when present, `shouldReport` callback is invoked to determine whether a diagnostic
+         * raised in the generated code should be propagated back to the original source code.
+         * Note that when this callback is present, diagnostic processing (e.g. typechecking) will
+         * still be performed, but the results will not be reported back to the original source code. */
         shouldReport?(source: string | undefined, code: string | number | undefined): boolean;
     };
     /** virtual code is expected to support assisted completion */
@@ -59,7 +77,16 @@ export interface CodeInformation {
         isAdditional?: boolean;
         onlyImport?: boolean;
     };
-    /** virtual code is expected correctly reflect semantic of the source code */
+    /** virtual code is expected correctly reflect semantic of the source code. Specifically this controls the following langauge features:
+     *
+     * - hover
+     * - inlay hints
+     * - code lens
+     * - semantic tokens
+     * - others
+     *
+     * Note that semantic diagnostics (e.g. TS type-checking) are covered by the `verification` property above.
+     */
     semantic?: boolean | {
         shouldHighlight?(): boolean;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@volar/language-core",
-	"version": "2.4.11",
+	"version": "2.4.13",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,7 +12,7 @@
 		"directory": "packages/language-core"
 	},
 	"dependencies": {
-		"@volar/source-map": "2.4.11"
+		"@volar/source-map": "2.4.13"
 	},
-	"gitHead": "42ccae005cc8516e07ad38f4d7730cab9b723340"
+	"gitHead": "c5d727b9e73d0c6a45c64b38d74ca5c52363818f"
 }