@vue/language-core 2.2.0 → 2.2.2

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) {
@@ -52,27 +55,30 @@ const plugin = ctx => {
 exports.default = plugin;
 function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
-    const lang = (0, alien_signals_1.computed)(() => {
+    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 getResolvedOptions = (0, alien_signals_1.computed)(() => {
         const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(_sfc.comments);
-        return options
-            ? (0, ts_1.resolveVueCompilerOptions)(options, ctx.vueCompilerOptions)
-            : ctx.vueCompilerOptions;
+        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
+    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;
+        const bindings = getScriptSetupRanges()?.bindings;
         if (_sfc.scriptSetup && bindings) {
             for (const { range } of bindings) {
                 newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
@@ -80,9 +86,9 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         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;
+        const bindings = getScriptSetupRanges()?.bindings;
         if (_sfc.scriptSetup && bindings) {
             for (const { range, moduleName, isDefaultImport, isNamespace } of bindings) {
                 if (moduleName
@@ -95,46 +101,60 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         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(),
+            vueCompilerOptions: getResolvedOptions(),
             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(),
+            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 getGeneratedScript = (0, alien_signals_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
         let generatedLength = 0;
         const codegen = (0, script_1.generateScript)({
             ts,
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: vueCompilerOptions.get(),
+            vueCompilerOptions: getResolvedOptions(),
             sfc: _sfc,
-            edited: vueCompilerOptions.get().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            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/plugins/vue-vine.d.ts

@@ -0,0 +1,3 @@
+import type { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;

package/lib/plugins/vue-vine.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("./shared");
+const plugin = () => {
+    return {
+        version: 2.1,
+        getEmbeddedCodes(_fileName, sfc) {
+            const result = [];
+            for (let i = 0; i < sfc.customBlocks.length; i++) {
+                const block = sfc.customBlocks[i];
+                if (block.type === 'vine') {
+                    result.push({
+                        id: 'vine_' + i,
+                        lang: block.lang,
+                    });
+                }
+            }
+            return result;
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id.startsWith('vine_')) {
+                const index = parseInt(embeddedFile.id.slice('vine_'.length));
+                const block = sfc.customBlocks[index];
+                embeddedFile.content.push([
+                    block.content,
+                    block.name,
+                    0,
+                    shared_1.allCodeFeatures,
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-vine.js.map

package/lib/types.d.ts

@@ -7,7 +7,8 @@ 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 {
@@ -22,7 +23,10 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
-    strictTemplates: boolean;
+    checkUnknownProps: boolean;
+    checkUnknownEvents: boolean;
+    checkUnknownDirectives: boolean;
+    checkUnknownComponents: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
     dataAttributes: string[];

package/lib/utils/findDestructuredProps.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/findDestructuredProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=findDestructuredProps.js.map

package/lib/utils/parseCssImports.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssImports(css: string): Generator<{
+    text: string;
+    offset: number;
+}, void, unknown>;

package/lib/utils/parseCssImports.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssImports = parseCssImports;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith('\'') || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+//# sourceMappingURL=parseCssImports.js.map

package/lib/utils/parseSfc.js

@@ -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;
@@ -118,8 +118,9 @@ function createBlock(node, source) {
                     };
                 }
             }
-            else if (type === 'script' && p.name === 'setup') {
-                block.setup = attrs.setup;
+            else if (type === 'script'
+                && (p.name === 'setup' || p.name === 'vapor')) {
+                block.setup = attrs[p.name];
             }
         }
     });

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;