@vue/language-core 3.3.5 → 3.3.6

package/index.d.ts

@@ -1,3 +1,4 @@
+export * from './lib/codegen/codeFeatures';
 export * from './lib/codegen/template';
 export * from './lib/compilerOptions';
 export * from './lib/languagePlugin';

package/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = exports.names = void 0;
+__exportStar(require("./lib/codegen/codeFeatures"), exports);
 __exportStar(require("./lib/codegen/template"), exports);
 __exportStar(require("./lib/compilerOptions"), exports);
 __exportStar(require("./lib/languagePlugin"), exports);

package/lib/codegen/codeFeatures.d.ts

@@ -1,86 +1,26 @@
 import type { VueCodeInformation } from '../types';
-declare const raw: {
-    all: {
-        verification: true;
-        completion: true;
-        semantic: true;
-        navigation: true;
-    };
-    importCompletionOnly: {
-        __importCompletion: true;
-    };
-    verification: {
-        verification: true;
-    };
-    completion: {
-        completion: true;
-    };
-    withoutCompletion: {
-        verification: true;
-        semantic: true;
-        navigation: true;
-    };
-    navigation: {
-        navigation: true;
-    };
-    navigationWithoutRename: {
-        navigation: {
-            shouldRename: () => false;
-        };
-    };
-    navigationAndCompletion: {
-        navigation: true;
-        completion: true;
-    };
-    navigationAndVerification: {
-        navigation: true;
-        verification: true;
-    };
-    withoutNavigation: {
-        verification: true;
-        completion: true;
-        semantic: true;
-    };
-    semanticWithoutHighlight: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-    };
-    withoutHighlight: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-        navigation: true;
-        completion: true;
-    };
-    withoutHighlightAndCompletion: {
-        semantic: {
-            shouldHighlight: () => false;
-        };
-        verification: true;
-        navigation: true;
-    };
-    withoutSemantic: {
-        verification: true;
-        navigation: true;
-        completion: true;
-    };
-    doNotReportTs2339AndTs2551: {
-        verification: {
-            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
-        };
-    };
-    doNotReportTs2353AndTs2561: {
-        verification: {
-            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
-        };
-    };
-    doNotReportTs6133: {
-        verification: {
-            shouldReport: (_source: string | undefined, code: string | number | undefined) => boolean;
-        };
-    };
+export declare const codeFeatures: {
+    full: VueCodeInformation;
+    all: VueCodeInformation;
+    importCompletionOnly: VueCodeInformation;
+    verification: VueCodeInformation;
+    completion: VueCodeInformation;
+    withoutCompletion: VueCodeInformation;
+    navigation: VueCodeInformation;
+    navigationWithoutRename: VueCodeInformation;
+    navigationAndCompletion: VueCodeInformation;
+    navigationAndVerification: VueCodeInformation;
+    withoutNavigation: VueCodeInformation;
+    semanticWithoutHighlight: VueCodeInformation;
+    withoutHighlight: VueCodeInformation;
+    withoutHighlightAndCompletion: VueCodeInformation;
+    withoutSemantic: VueCodeInformation;
+    structure: VueCodeInformation;
+    structureAndFormat: VueCodeInformation;
+    format: VueCodeInformation;
+    doNotReportTs2339AndTs2551: VueCodeInformation;
+    doNotReportTs2353AndTs2561: VueCodeInformation;
+    doNotReportTs6133: VueCodeInformation;
 };
-export declare const codeFeatures: { [K in keyof typeof raw]: VueCodeInformation; };
-export {};
+/** @deprecated use `codeFeatures.full` instead */
+export declare const allCodeFeatures: VueCodeInformation;

package/lib/codegen/codeFeatures.js

@@ -1,65 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codeFeatures = void 0;
-const raw = {
+exports.allCodeFeatures = exports.codeFeatures = void 0;
+exports.codeFeatures = defineCodeFeatures({
+    full: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+        structure: true,
+        format: true,
+    },
+    /** @internal */
     all: {
         verification: true,
         completion: true,
         semantic: true,
         navigation: true,
     },
+    /** @internal */
     importCompletionOnly: {
         __importCompletion: true,
     },
+    /** @internal */
     verification: {
         verification: true,
     },
+    /** @internal */
     completion: {
         completion: true,
     },
+    /** @internal */
     withoutCompletion: {
         verification: true,
         semantic: true,
         navigation: true,
     },
+    /** @internal */
     navigation: {
         navigation: true,
     },
+    /** @internal */
     navigationWithoutRename: {
         navigation: { shouldRename: () => false },
     },
+    /** @internal */
     navigationAndCompletion: {
         navigation: true,
         completion: true,
     },
+    /** @internal */
     navigationAndVerification: {
         navigation: true,
         verification: true,
     },
+    /** @internal */
     withoutNavigation: {
         verification: true,
         completion: true,
         semantic: true,
     },
+    /** @internal */
     semanticWithoutHighlight: {
         semantic: { shouldHighlight: () => false },
     },
+    /** @internal */
     withoutHighlight: {
         semantic: { shouldHighlight: () => false },
         verification: true,
         navigation: true,
         completion: true,
     },
+    /** @internal */
     withoutHighlightAndCompletion: {
         semantic: { shouldHighlight: () => false },
         verification: true,
         navigation: true,
     },
+    /** @internal */
     withoutSemantic: {
         verification: true,
         navigation: true,
         completion: true,
     },
+    /** @internal */
+    structure: {
+        structure: true,
+    },
+    /** @internal */
+    structureAndFormat: {
+        structure: true,
+        format: true,
+    },
+    /** @internal */
+    format: {
+        format: true,
+    },
+    /** @internal */
     doNotReportTs2339AndTs2551: {
         verification: {
             // https://typescript.tv/errors/#ts2339
@@ -67,6 +103,7 @@ const raw = {
             shouldReport: (_source, code) => String(code) !== '2339' && String(code) !== '2551',
         },
     },
+    /** @internal */
     doNotReportTs2353AndTs2561: {
         verification: {
             // https://typescript.tv/errors/#ts2353
@@ -74,12 +111,17 @@ const raw = {
             shouldReport: (_source, code) => String(code) !== '2353' && String(code) !== '2561',
         },
     },
+    /** @internal */
     doNotReportTs6133: {
         verification: {
             // https://typescript.tv/errors/#ts6133
             shouldReport: (_source, code) => String(code) !== '6133',
         },
     },
-};
-exports.codeFeatures = raw;
+});
+/** @deprecated use `codeFeatures.full` instead */
+exports.allCodeFeatures = exports.codeFeatures.full;
+function defineCodeFeatures(features) {
+    return features;
+}
 //# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/names.d.ts

@@ -50,10 +50,9 @@ declare const raw: {
     ConstructorOverloads: string;
     Elements: string;
     EmitsToProps: string;
-    FunctionalComponent0: string;
-    FunctionalComponent1: string;
-    FunctionalComponentCtx: string;
-    FunctionalComponentProps: string;
+    ExtractComponentContext: string;
+    ExtractComponentProps: string;
+    FunctionalComponent: string;
     IsAny: string;
     IsFunction: string;
     NormalizeEmits: string;

package/lib/codegen/names.js

@@ -54,10 +54,9 @@ const raw = {
     ConstructorOverloads: '',
     Elements: '',
     EmitsToProps: '',
-    FunctionalComponent0: '',
-    FunctionalComponent1: '',
-    FunctionalComponentCtx: '',
-    FunctionalComponentProps: '',
+    ExtractComponentContext: '',
+    ExtractComponentProps: '',
+    FunctionalComponent: '',
     IsAny: '',
     IsFunction: '',
     NormalizeEmits: '',

package/lib/codegen/script/index.js

@@ -61,15 +61,15 @@ function* generateWorker(options, ctx) {
             src = src.slice(0, -'.tsx'.length) + '.jsx';
         }
         yield `import ${names_1.names.src} from `;
-        const token = yield* (0, boundary_1.startBoundary)('main', script.src.offset, {
+        const boundary = yield* boundary_1.Boundary.start('main', script.src.offset, {
             ...codeFeatures_1.codeFeatures.all,
             ...src !== script.src.text ? codeFeatures_1.codeFeatures.navigationWithoutRename : {},
         });
         yield `'`;
-        yield [src.slice(0, script.src.text.length), 'main', script.src.offset, { __combineToken: token }];
+        yield [src.slice(0, script.src.text.length), 'main', script.src.offset, boundary.features];
         yield src.slice(script.src.text.length);
         yield `'`;
-        yield (0, boundary_1.endBoundary)(token, script.src.offset + script.src.text.length);
+        yield boundary.end(script.src.offset + script.src.text.length);
         yield utils_1.endOfLine;
         yield `export default ${names_1.names.src}${utils_1.endOfLine}`;
         yield* (0, template_1.generateTemplate)(options, ctx, names_1.names.src);
@@ -194,9 +194,9 @@ function* generateGlobalTypesReference({ typesRoot, lib, target, checkUnknownPro
 }
 function* generateExportDeclareEqual(block, name) {
     yield `const `;
-    const token = yield* (0, boundary_1.startBoundary)(block.name, 0, codeFeatures_1.codeFeatures.doNotReportTs6133);
+    const boundary = yield* boundary_1.Boundary.start(block.name, 0, codeFeatures_1.codeFeatures.doNotReportTs6133);
     yield name;
-    yield (0, boundary_1.endBoundary)(token, block.content.length);
+    yield boundary.end(block.content.length);
     yield ` = `;
 }
 //# sourceMappingURL=index.js.map

package/lib/codegen/script/scriptSetup.js

@@ -90,7 +90,7 @@ function* generateGeneric(options, ctx, scriptSetup, scriptSetupRanges, generic,
     yield `	emit: ${emitTypes.length ? emitTypes.join(` & `) : `{}`}${utils_1.endOfLine}`;
     yield `}${utils_1.endOfLine}`;
     yield `})(),${utils_1.newLine}`; // __VLS_setup = (async () => {
-    yield `) => ({} as import('${vueCompilerOptions.lib}').VNode & { __ctx?: Awaited<typeof ${names_1.names.setup}> }))${utils_1.endOfLine}`;
+    yield `) => ({} as import('${vueCompilerOptions.lib}').VNode & { __ctx?: NonNullable<Awaited<typeof ${names_1.names.setup}>> }))${utils_1.endOfLine}`;
 }
 function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, body, output) {
     const transforms = [];
@@ -161,9 +161,9 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, bo
         else {
             transforms.push((0, transform_1.insert)(callExp.end, function* () {
                 yield ` as ${type}[`;
-                const token = yield* (0, boundary_1.startBoundary)(scriptSetup.name, exp.start, codeFeatures_1.codeFeatures.verification);
+                const boundary = yield* boundary_1.Boundary.start(scriptSetup.name, exp.start, codeFeatures_1.codeFeatures.verification);
                 yield `'$style'`;
-                yield (0, boundary_1.endBoundary)(token, exp.end);
+                yield boundary.end(exp.end);
                 yield `])`;
             }));
         }
@@ -270,7 +270,7 @@ function* generateDefineWithTypeTransforms(scriptSetup, statement, callExp, type
             });
         }
     }
-    else if (!utils_1.identifierRegex.test(name)) {
+    else if (!utils_1.identifierRE.test(name)) {
         yield (0, transform_1.replace)(statement.start, callExp.start, function* () {
             yield `const ${defaultName} = `;
         });

package/lib/codegen/style/common.js

@@ -7,26 +7,22 @@ const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 function* generateClassProperty(source, classNameWithDot, offset, propertyType) {
     yield `${utils_1.newLine} & { `;
-    const token = yield* (0, boundary_1.startBoundary)(source, offset, codeFeatures_1.codeFeatures.navigation);
+    const boundary = yield* boundary_1.Boundary.start(source, offset, codeFeatures_1.codeFeatures.navigation);
     yield `'`;
-    yield [classNameWithDot.slice(1), source, offset + 1, { __combineToken: token }];
+    yield [classNameWithDot.slice(1), source, offset + 1, boundary.features];
     yield `'`;
-    yield (0, boundary_1.endBoundary)(token, offset + classNameWithDot.length);
+    yield boundary.end(offset + classNameWithDot.length);
     yield `: ${propertyType}`;
     yield ` }`;
 }
 function* generateStyleImports(style) {
-    const features = {
-        navigation: true,
-        verification: true,
-    };
     if (typeof style.src === 'object') {
         yield `${utils_1.newLine} & typeof import(`;
-        const token = yield* (0, boundary_1.startBoundary)('main', style.src.offset, features);
+        const boundary = yield* boundary_1.Boundary.start('main', style.src.offset, codeFeatures_1.codeFeatures.navigationAndVerification);
         yield `'`;
-        yield [style.src.text, 'main', style.src.offset, { __combineToken: token }];
+        yield [style.src.text, 'main', style.src.offset, boundary.features];
         yield `'`;
-        yield (0, boundary_1.endBoundary)(token, style.src.offset + style.src.text.length);
+        yield boundary.end(style.src.offset + style.src.text.length);
         yield `).default`;
     }
     for (const { text, offset } of style.imports) {
@@ -35,7 +31,7 @@ function* generateStyleImports(style) {
             text,
             style.name,
             offset,
-            features,
+            codeFeatures_1.codeFeatures.navigationAndVerification,
         ];
         yield `').default`;
     }

package/lib/codegen/style/index.d.ts

@@ -8,8 +8,7 @@ export interface StyleCodegenOptions {
 }
 export { generate as generateStyle };
 declare function generate(options: StyleCodegenOptions): {
-    generatedTypes: Set<string>;
-    currentInfo: {
+    getCommentInfo: () => {
         ignoreError?: boolean;
         expectError?: {
             token: number;
@@ -20,41 +19,70 @@ declare function generate(options: StyleCodegenOptions): {
             offset: number;
         };
     };
+    enter: (node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode) => boolean;
+    exit: () => Generator<Code>;
     resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
-    inVFor: boolean;
+    getInternalVariable: () => string;
+    scopes: {
+        add(value: string): /*elided*/ any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    }[];
+    scope: () => {
+        add(value: string): any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    };
+    contextAccesses: Map<string, Map<string, Set<number>>>;
+    accessVariable: (source: string, name: string, offset?: number) => void;
+    generateAutoImport: () => Generator<Code>;
+    conditions: string[];
+    generateConditionGuards: () => Generator<string, void, unknown>;
+    hoistVars: Map<string, string>;
+    getHoistVariable: (originalVar: string) => string;
+    generateHoistVariables: () => Generator<string, void, unknown>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }[]>;
+    addTemplateRef: (name: string, typeExp: string, offset: number) => void;
+    components: (() => string)[];
+    dollarVars: Set<string>;
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+    generatedTypes: Set<string>;
+    inheritedAttrVars: Set<string>;
+    singleRootElTypes: Set<string>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     slots: {
         name: string;
         offset?: number;
         tagRange: [number, number];
-        nodeLoc: any;
         propsVar: string;
     }[];
     dynamicSlots: {
         expVar: string;
         propsVar: string;
     }[];
-    dollarVars: Set<string>;
-    componentAccessMap: Map<string, Map<string, Set<number>>>;
-    blockConditions: string[];
-    inlayHints: import("../inlayHints").InlayHintInfo[];
-    inheritedAttrVars: Set<string>;
-    templateRefs: Map<string, {
-        typeExp: string;
-        offset: number;
-    }[]>;
-    singleRootElTypes: Set<string>;
-    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
-    addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number): void;
-    scopes: Set<string>[];
-    components: (() => string)[];
-    declare(...varNames: string[]): void;
-    startScope(): () => Generator<Code, any, any>;
-    getInternalVariable(): string;
-    getHoistVariable(originalVar: string): string;
-    generateHoistVariables(): Generator<string, void, unknown>;
-    generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
-    exit(): Generator<Code>;
+    inVFor: boolean;
     codes: Code[];
 };

package/lib/codegen/style/index.js

@@ -20,12 +20,12 @@ function generate(options) {
     return { ...ctx, codes };
 }
 function* generateWorker(options, ctx) {
-    const endScope = ctx.startScope();
-    ctx.declare(...options.setupConsts);
+    const scope = ctx.scope();
+    scope.declare(...options.setupConsts);
     yield* (0, scopedClasses_1.generateStyleScopedClasses)(options);
     yield* (0, modules_1.generateStyleModules)(options, ctx);
     yield* generateCssVars(options, ctx);
-    yield* endScope();
+    yield* scope.end();
 }
 function* generateCssVars(options, ctx) {
     for (const style of options.styles) {