@vue/language-core 2.2.0 → 2.2.4

package/lib/plugins/vue-tsx.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
+const shared_1 = require("@vue/shared");
 const alien_signals_1 = require("alien-signals");
+const path = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
 const vueCompilerOptions_1 = require("../parsers/vueCompilerOptions");
+const signals_1 = require("../utils/signals");
 const ts_1 = require("../utils/ts");
 exports.tsCodegen = new WeakMap();
 const fileEditTimes = new Map();
@@ -19,17 +22,17 @@ const plugin = ctx => {
             'exactOptionalPropertyTypes',
         ],
         getEmbeddedCodes(fileName, sfc) {
-            const tsx = useTsx(fileName, sfc);
+            const codegen = useCodegen(fileName, sfc);
             const files = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang.get())) {
-                files.push({ id: 'script_' + tsx.lang.get(), lang: tsx.lang.get() });
+            if (['js', 'ts', 'jsx', 'tsx'].includes(codegen.getLang())) {
+                files.push({ id: 'script_' + codegen.getLang(), lang: codegen.getLang() });
             }
             return files;
         },
         resolveEmbeddedCode(fileName, sfc, embeddedFile) {
-            const _tsx = useTsx(fileName, sfc);
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
-                const tsx = _tsx.generatedScript.get();
+                const codegen = useCodegen(fileName, sfc);
+                const tsx = codegen.getGeneratedScript();
                 if (tsx) {
                     embeddedFile.content = [...tsx.codes];
                     embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
@@ -37,7 +40,7 @@ const plugin = ctx => {
             }
         },
     };
-    function useTsx(fileName, sfc) {
+    function useCodegen(fileName, sfc) {
         if (!exports.tsCodegen.has(sfc)) {
             let appendGlobalTypes = false;
             if (!ctx.vueCompilerOptions.__setupedGlobalTypes && !appendedGlobalTypes) {
@@ -50,91 +53,108 @@ const plugin = ctx => {
     }
 };
 exports.default = plugin;
-function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
+function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
-    const lang = (0, alien_signals_1.computed)(() => {
-        return !_sfc.script && !_sfc.scriptSetup ? 'ts'
-            : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
-                : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+    const getLang = (0, alien_signals_1.computed)(() => {
+        return !sfc.script && !sfc.scriptSetup ? 'ts'
+            : sfc.scriptSetup && sfc.scriptSetup.lang !== 'js' ? sfc.scriptSetup.lang
+                : sfc.script && sfc.script.lang !== 'js' ? sfc.script.lang
                     : 'js';
     });
-    const vueCompilerOptions = (0, alien_signals_1.computed)(() => {
-        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(_sfc.comments);
-        return options
-            ? (0, ts_1.resolveVueCompilerOptions)(options, ctx.vueCompilerOptions)
-            : ctx.vueCompilerOptions;
+    const getResolvedOptions = (0, alien_signals_1.computed)(() => {
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
+        if (options) {
+            const resolver = new ts_1.CompilerOptionsResolver();
+            resolver.addConfig(options, path.dirname(fileName));
+            return resolver.build(ctx.vueCompilerOptions);
+        }
+        return ctx.vueCompilerOptions;
     });
-    const scriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
+    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup, false)
         : undefined);
-    const scriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, vueCompilerOptions.get())
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
         : undefined);
-    const scriptSetupBindingNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+    const getSetupBindingNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
         const newNames = new Set();
-        const bindings = scriptSetupRanges.get()?.bindings;
-        if (_sfc.scriptSetup && bindings) {
+        const bindings = getScriptSetupRanges()?.bindings;
+        if (sfc.scriptSetup && bindings) {
             for (const { range } of bindings) {
-                newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                newNames.add(sfc.scriptSetup.content.slice(range.start, range.end));
             }
         }
         return newNames;
     }));
-    const scriptSetupImportComponentNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
+    const getSetupImportComponentNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
         const newNames = new Set();
-        const bindings = scriptSetupRanges.get()?.bindings;
-        if (_sfc.scriptSetup && bindings) {
+        const bindings = getScriptSetupRanges()?.bindings;
+        if (sfc.scriptSetup && bindings) {
             for (const { range, moduleName, isDefaultImport, isNamespace } of bindings) {
                 if (moduleName
                     && isDefaultImport
                     && !isNamespace
                     && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                    newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                    newNames.add(sfc.scriptSetup.content.slice(range.start, range.end));
                 }
             }
         }
         return newNames;
     }));
-    const destructuredPropNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
-        const newNames = new Set(scriptSetupRanges.get()?.defineProps?.destructured);
-        const rest = scriptSetupRanges.get()?.defineProps?.destructuredRest;
+    const getSetupDestructuredPropNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(getScriptSetupRanges()?.defineProps?.destructured?.keys());
+        const rest = getScriptSetupRanges()?.defineProps?.destructuredRest;
         if (rest) {
             newNames.add(rest);
         }
         return newNames;
     }));
-    const templateRefNames = alien_signals_1.unstable.computedSet((0, alien_signals_1.computed)(() => {
-        const newNames = new Set(scriptSetupRanges.get()?.useTemplateRef
+    const getSetupTemplateRefNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(getScriptSetupRanges()?.useTemplateRef
             .map(({ name }) => name)
             .filter(name => name !== undefined));
         return newNames;
     }));
-    const hasDefineSlots = (0, alien_signals_1.computed)(() => !!scriptSetupRanges.get()?.defineSlots);
-    const slotsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.defineSlots?.name);
-    const propsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.defineProps?.name);
-    const inheritAttrs = (0, alien_signals_1.computed)(() => {
-        const value = scriptSetupRanges.get()?.defineOptions?.inheritAttrs ?? scriptRanges.get()?.exportDefault?.inheritAttrsOption;
+    const setupHasDefineSlots = (0, alien_signals_1.computed)(() => !!getScriptSetupRanges()?.defineSlots);
+    const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
+    const getSetupPropsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineProps?.name);
+    const getSetupInheritAttrs = (0, alien_signals_1.computed)(() => {
+        const value = getScriptSetupRanges()?.defineOptions?.inheritAttrs ?? getScriptRanges()?.exportDefault?.inheritAttrsOption;
         return value !== 'false';
     });
-    const generatedTemplate = (0, alien_signals_1.computed)(() => {
-        if (vueCompilerOptions.get().skipTemplateCodegen || !_sfc.template) {
+    const getComponentSelfName = (0, alien_signals_1.computed)(() => {
+        const { exportDefault } = getScriptRanges() ?? {};
+        if (sfc.script && exportDefault?.nameOption) {
+            const { nameOption } = exportDefault;
+            return sfc.script.content.slice(nameOption.start + 1, nameOption.end - 1);
+        }
+        const { defineOptions } = getScriptSetupRanges() ?? {};
+        if (sfc.scriptSetup && defineOptions?.name) {
+            return defineOptions.name;
+        }
+        const baseName = path.basename(fileName);
+        return (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
+    });
+    const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
+        if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
             return;
         }
         const codes = [];
         const codegen = (0, template_1.generateTemplate)({
             ts,
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: vueCompilerOptions.get(),
-            template: _sfc.template,
-            edited: vueCompilerOptions.get().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
-            scriptSetupBindingNames: scriptSetupBindingNames.get(),
-            scriptSetupImportComponentNames: scriptSetupImportComponentNames.get(),
-            destructuredPropNames: destructuredPropNames.get(),
-            templateRefNames: templateRefNames.get(),
-            hasDefineSlots: hasDefineSlots.get(),
-            slotsAssignName: slotsAssignName.get(),
-            propsAssignName: propsAssignName.get(),
-            inheritAttrs: inheritAttrs.get(),
+            vueCompilerOptions: getResolvedOptions(),
+            template: sfc.template,
+            edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            scriptSetupBindingNames: getSetupBindingNames(),
+            scriptSetupImportComponentNames: getSetupImportComponentNames(),
+            destructuredPropNames: getSetupDestructuredPropNames(),
+            templateRefNames: getSetupTemplateRefNames(),
+            hasDefineSlots: setupHasDefineSlots(),
+            slotsAssignName: getSetupSlotsAssignName(),
+            propsAssignName: getSetupPropsAssignName(),
+            inheritAttrs: getSetupInheritAttrs(),
+            selfComponentName: getComponentSelfName(),
         });
         let current = codegen.next();
         while (!current.done) {
@@ -144,26 +164,26 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         return {
             ...current.value,
-            codes: codes,
+            codes,
         };
     });
-    const generatedScript = (0, alien_signals_1.computed)(() => {
-        const codes = [];
+    const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         const linkedCodeMappings = [];
         let generatedLength = 0;
+        const codes = [];
         const codegen = (0, script_1.generateScript)({
             ts,
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: vueCompilerOptions.get(),
-            sfc: _sfc,
-            edited: vueCompilerOptions.get().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            vueCompilerOptions: getResolvedOptions(),
+            sfc: sfc,
+            edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             fileName,
-            lang: lang.get(),
-            scriptRanges: scriptRanges.get(),
-            scriptSetupRanges: scriptSetupRanges.get(),
-            templateCodegen: generatedTemplate.get(),
-            destructuredPropNames: destructuredPropNames.get(),
-            templateRefNames: templateRefNames.get(),
+            lang: getLang(),
+            scriptRanges: getScriptRanges(),
+            scriptSetupRanges: getScriptSetupRanges(),
+            templateCodegen: getGeneratedTemplate(),
+            destructuredPropNames: getSetupDestructuredPropNames(),
+            templateRefNames: getSetupTemplateRefNames(),
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
             appendGlobalTypes,
@@ -185,11 +205,11 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         };
     });
     return {
-        scriptRanges,
-        scriptSetupRanges,
-        lang,
-        generatedScript,
-        generatedTemplate,
+        getScriptRanges,
+        getScriptSetupRanges,
+        getLang,
+        getGeneratedScript,
+        getGeneratedTemplate,
     };
 }
 //# sourceMappingURL=vue-tsx.js.map

package/lib/types.d.ts

@@ -7,12 +7,12 @@ import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
 export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
-    target?: 'auto' | 2 | 2.7 | 3 | 3.3;
+    strictTemplates?: boolean;
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 99 | number;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
-    __combineLastMapping?: boolean;
-    __combineOffsetMapping?: number;
+    __combineOffset?: number;
 }
 export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
@@ -22,9 +22,19 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
-    strictTemplates: boolean;
+    checkUnknownProps: boolean;
+    checkUnknownEvents: boolean;
+    checkUnknownDirectives: boolean;
+    checkUnknownComponents: boolean;
+    inferComponentDollarEl: boolean;
+    inferComponentDollarRefs: boolean;
+    inferTemplateDollarAttrs: boolean;
+    inferTemplateDollarEl: boolean;
+    inferTemplateDollarRefs: boolean;
+    inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
+    fallthroughComponentNames: string[];
     dataAttributes: string[];
     htmlAttributes: string[];
     optionsWrapper: [string, string] | [];
@@ -99,6 +109,11 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
+export type SfcBlockAttr = true | {
+    text: string;
+    offset: number;
+    quotes: boolean;
+};
 export interface Sfc {
     content: string;
     comments: string[];
@@ -108,21 +123,16 @@ export interface Sfc {
         warnings: CompilerDOM.CompilerError[];
     } | undefined;
     script: (SfcBlock & {
-        src: string | undefined;
-        srcOffset: number;
+        src: SfcBlockAttr | undefined;
         ast: ts.SourceFile;
     }) | undefined;
     scriptSetup: SfcBlock & {
-        generic: string | undefined;
-        genericOffset: number;
+        generic: SfcBlockAttr | undefined;
         ast: ts.SourceFile;
     } | undefined;
     styles: readonly (SfcBlock & {
         scoped: boolean;
-        module?: {
-            name: string;
-            offset?: number;
-        };
+        module?: SfcBlockAttr | undefined;
         cssVars: {
             text: string;
             offset: number;
@@ -137,11 +147,14 @@ export interface Sfc {
     })[];
 }
 declare module '@vue/compiler-sfc' {
+    interface SFCBlock {
+        __src?: SfcBlockAttr;
+    }
+    interface SFCScriptBlock {
+        __generic?: SfcBlockAttr;
+    }
     interface SFCStyleBlock {
-        __module?: {
-            name: string;
-            offset?: number;
-        };
+        __module?: SfcBlockAttr;
     }
 }
 export interface TextRange {

package/lib/utils/parseSfc.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = parse;
-const compiler = require("@vue/compiler-dom");
+const CompilerDOM = require("@vue/compiler-dom");
 function parse(source) {
     const errors = [];
-    const ast = compiler.parse(source, {
+    const ast = CompilerDOM.parse(source, {
         // there are no components at SFC parsing level
         isNativeTag: () => true,
         // preserve all whitespaces
@@ -29,11 +29,11 @@ function parse(source) {
         shouldForceReload: () => false,
     };
     ast.children.forEach(node => {
-        if (node.type === compiler.NodeTypes.COMMENT) {
+        if (node.type === CompilerDOM.NodeTypes.COMMENT) {
             descriptor.comments.push(node.content);
             return;
         }
-        else if (node.type !== compiler.NodeTypes.ELEMENT) {
+        else if (node.type !== CompilerDOM.NodeTypes.ELEMENT) {
             return;
         }
         switch (node.tag) {
@@ -42,7 +42,7 @@ function parse(source) {
                 break;
             case 'script':
                 const scriptBlock = createBlock(node, source);
-                const isSetup = !!scriptBlock.attrs.setup;
+                const isSetup = !!scriptBlock.setup;
                 if (isSetup && !descriptor.scriptSetup) {
                     descriptor.scriptSetup = scriptBlock;
                     break;
@@ -99,30 +99,55 @@ function createBlock(node, source) {
         attrs
     };
     node.props.forEach(p => {
-        if (p.type === compiler.NodeTypes.ATTRIBUTE) {
+        if (p.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
             attrs[p.name] = p.value ? p.value.content || true : true;
             if (p.name === 'lang') {
-                block.lang = p.value && p.value.content;
+                block.lang = p.value?.content;
             }
             else if (p.name === 'src') {
-                block.src = p.value && p.value.content;
+                block.__src = parseAttr(p, node);
             }
-            else if (type === 'style') {
+            else if (isScriptBlock(block)) {
+                if (p.name === 'setup' || p.name === 'vapor') {
+                    block.setup = attrs[p.name];
+                }
+                else if (p.name === 'generic') {
+                    block.__generic = parseAttr(p, node);
+                }
+            }
+            else if (isStyleBlock(block)) {
                 if (p.name === 'scoped') {
                     block.scoped = true;
                 }
                 else if (p.name === 'module') {
-                    block.__module = {
-                        name: p.value?.content ?? '$style',
-                        offset: p.value?.content ? p.value?.loc.start.offset - node.loc.start.offset : undefined
-                    };
+                    block.__module = parseAttr(p, node);
                 }
             }
-            else if (type === 'script' && p.name === 'setup') {
-                block.setup = attrs.setup;
-            }
         }
     });
     return block;
 }
+function isScriptBlock(block) {
+    return block.type === 'script';
+}
+function isStyleBlock(block) {
+    return block.type === 'style';
+}
+function parseAttr(p, node) {
+    if (!p.value) {
+        return true;
+    }
+    const text = p.value.content;
+    const source = p.value.loc.source;
+    let offset = p.value.loc.start.offset - node.loc.start.offset;
+    const quotes = source.startsWith('"') || source.startsWith("'");
+    if (quotes) {
+        offset++;
+    }
+    return {
+        text,
+        offset,
+        quotes,
+    };
+}
 //# sourceMappingURL=parseSfc.js.map

package/lib/utils/signals.d.ts

@@ -0,0 +1,2 @@
+export declare function computedArray<I, O>(arr: () => I[], getGetter: (item: () => I, index: number) => () => O): readonly Readonly<O>[];
+export declare function computedSet<T>(source: () => Set<T>): () => Set<T>;

package/lib/utils/signals.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedArray = computedArray;
+exports.computedSet = computedSet;
+const alien_signals_1 = require("alien-signals");
+function computedArray(arr, getGetter) {
+    const length = (0, alien_signals_1.computed)(() => arr().length);
+    const keys = (0, alien_signals_1.computed)(() => {
+        const keys = [];
+        for (let i = 0; i < length(); i++) {
+            keys.push(String(i));
+        }
+        return keys;
+    });
+    const items = (0, alien_signals_1.computed)(array => {
+        array ??= [];
+        while (array.length < length()) {
+            const index = array.length;
+            const item = (0, alien_signals_1.computed)(() => arr()[index]);
+            array.push((0, alien_signals_1.computed)(getGetter(item, index)));
+        }
+        if (array.length > length()) {
+            array.length = length();
+        }
+        return array;
+    });
+    return new Proxy({}, {
+        get(_, p, receiver) {
+            if (p === 'length') {
+                return length();
+            }
+            if (typeof p === 'string' && !isNaN(Number(p))) {
+                return items()[Number(p)]?.();
+            }
+            return Reflect.get(items(), p, receiver);
+        },
+        has(_, p) {
+            return Reflect.has(items(), p);
+        },
+        ownKeys() {
+            return keys();
+        },
+    });
+}
+function computedSet(source) {
+    return (0, alien_signals_1.computed)(oldValue => {
+        const newValue = source();
+        if (oldValue?.size === newValue.size && [...oldValue].every(c => newValue.has(c))) {
+            return oldValue;
+        }
+        return newValue;
+    });
+}
+//# sourceMappingURL=signals.js.map

package/lib/utils/ts.d.ts

@@ -1,5 +1,5 @@
 import type * as ts from 'typescript';
-import type { VueCompilerOptions } from '../types';
+import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from '../types';
 export type ParsedCommandLine = ts.ParsedCommandLine & {
     vueOptions: VueCompilerOptions;
 };
@@ -7,7 +7,19 @@ export declare function createParsedCommandLineByJson(ts: typeof import('typescr
     writeFile?(path: string, data: string): void;
 }, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
 export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
-export declare function resolveVueCompilerOptions(options: Partial<VueCompilerOptions>, defaults?: VueCompilerOptions): VueCompilerOptions;
+export declare class CompilerOptionsResolver {
+    options: Omit<RawVueCompilerOptions, 'target' | 'plugin'>;
+    fallbackTarget: number | undefined;
+    target: number | undefined;
+    plugins: VueLanguagePlugin[];
+    addConfig(options: RawVueCompilerOptions, rootDir: string): void;
+    build(defaults?: VueCompilerOptions): VueCompilerOptions;
+}
+export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
+/**
+ * @deprecated use `getDefaultCompilerOptions` instead
+ */
+export declare function resolveVueCompilerOptions(options: Partial<VueCompilerOptions>): VueCompilerOptions;
 export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
     fileExists(path: string): boolean;
     writeFile?(path: string, data: string): void;