@dcloudio/uni-app-uts 3.0.0-3080720230630001

package/dist/plugins/uvue/compiler/transforms/vOn.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOn = exports.inlineStatementCannotUseEventMsg = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const errors_1 = require("../errors");
+const transformExpression_1 = require("./transformExpression");
+const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+exports.inlineStatementCannotUseEventMsg = 'Inline statement cannot use $event, please use a function expression instead.';
+// TODO: inline statement $event type complement
+const transformOn = (dir, node, context, augmentor) => {
+    const { loc, modifiers, arg } = dir;
+    if (loc.source.indexOf('($event)') !== -1) {
+        throw new Error(exports.inlineStatementCannotUseEventMsg);
+    }
+    if (!dir.exp && !modifiers.length) {
+        context.onError((0, errors_1.createCompilerError)(35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */, loc));
+    }
+    let eventName;
+    if (arg.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+        if (arg.isStatic) {
+            let rawName = arg.content;
+            // TODO deprecate @vnodeXXX usage
+            if (rawName.startsWith('vue:')) {
+                rawName = `vnode-${rawName.slice(4)}`;
+            }
+            const eventString = node.tagType !== 0 /* ElementTypes.ELEMENT */ ||
+                rawName.startsWith('vnode') ||
+                !/[A-Z]/.test(rawName)
+                ? // for non-element and vnode lifecycle event listeners, auto convert
+                    // it to camelCase. See issue #2249
+                    (0, shared_1.toHandlerKey)((0, shared_1.camelize)(rawName))
+                : // preserve case for plain element listeners that have uppercase
+                    // letters, as these may be custom elements' custom events
+                    `on:${rawName}`;
+            eventName = (0, compiler_core_1.createSimpleExpression)(eventString, true, arg.loc);
+        }
+        else {
+            // #2388
+            eventName = (0, compiler_core_1.createCompoundExpression)([
+                `${context.helperString(compiler_core_1.TO_HANDLER_KEY)}(`,
+                arg,
+                `)`,
+            ]);
+        }
+    }
+    else {
+        // already a compound expression.
+        eventName = arg;
+        eventName.children.unshift(`${context.helperString(compiler_core_1.TO_HANDLER_KEY)}(`);
+        eventName.children.push(`)`);
+    }
+    // handler processing
+    let exp = dir.exp;
+    if (exp && !exp.content.trim()) {
+        exp = undefined;
+    }
+    // @ts-ignore
+    let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
+    if (exp) {
+        // @ts-ignore
+        const isMemberExp = (0, compiler_core_1.isMemberExpression)(exp.content, context);
+        const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
+        const hasMultipleStatements = exp.content.includes(`;`);
+        // process the expression since it's been skipped
+        if (context.prefixIdentifiers) {
+            isInlineStatement && context.addIdentifiers(`$event`);
+            exp = dir.exp = (0, transformExpression_1.processExpression)(exp, context, false, hasMultipleStatements);
+            isInlineStatement && context.removeIdentifiers(`$event`);
+            // with scope analysis, the function is hoistable if it has no reference
+            // to scope variables.
+            shouldCache =
+                // @ts-ignore
+                context.cacheHandlers &&
+                    // unnecessary to cache inside v-once
+                    !context.inVOnce &&
+                    // runtime constants don't need to be cached
+                    // (this is analyzed by compileScript in SFC <script setup>)
+                    !(exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && exp.constType > 0) &&
+                    // #1541 bail if this is a member exp handler passed to a component -
+                    // we need to use the original function to preserve arity,
+                    // e.g. <transition> relies on checking cb.length to determine
+                    // transition end handling. Inline function is ok since its arity
+                    // is preserved even when cached.
+                    !(isMemberExp && node.tagType === 1 /* ElementTypes.COMPONENT */) &&
+                    // bail if the function references closure variables (v-for, v-slot)
+                    // it must be passed fresh to avoid stale values.
+                    !(0, compiler_core_1.hasScopeRef)(exp, context.identifiers);
+            // If the expression is optimizable and is a member expression pointing
+            // to a function, turn it into invocation (and wrap in an arrow function
+            // below) so that it always accesses the latest value when called - thus
+            // avoiding the need to be patched.
+            if (shouldCache && isMemberExp) {
+                if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+                    exp.content = `${exp.content} && ${exp.content}(...args)`;
+                }
+                else {
+                    exp.children = [...exp.children, ` && `, ...exp.children, `(...args)`];
+                }
+            }
+        }
+        if (isInlineStatement || (shouldCache && isMemberExp)) {
+            // wrap inline statement in a function expression
+            if (isInlineStatement && exp.loc.source.includes('$event')) {
+                throw new Error(exports.inlineStatementCannotUseEventMsg);
+            }
+            exp = (0, compiler_core_1.createCompoundExpression)([
+                `${isInlineStatement ? `()` : `${``}(...args)`
+                // } => ${hasMultipleStatements ? `{` : `(`}`,
+                } => ${`{`}`,
+                exp,
+                // hasMultipleStatements ? `}` : `)`
+                `}`,
+            ]);
+        }
+    }
+    let ret = {
+        props: [
+            (0, compiler_core_1.createObjectProperty)(eventName, exp || (0, compiler_core_1.createSimpleExpression)(`() => {}`, false, loc)),
+        ],
+    };
+    // apply extended compiler augmentor
+    if (augmentor) {
+        ret = augmentor(ret);
+    }
+    if (shouldCache) {
+        // cache handlers so that it's always the same handler being passed down.
+        // this avoids unnecessary re-renders when users use inline handlers on
+        // components.
+        ret.props[0].value = context.cache(ret.props[0].value);
+    }
+    // mark the key as handler for props normalization check
+    ret.props.forEach((p) => (p.key.isHandlerKey = true));
+    return ret;
+};
+exports.transformOn = transformOn;

package/dist/plugins/uvue/compiler/transforms/vShow.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveTransform } from '@vue/compiler-core';
+export declare const transformShow: DirectiveTransform;

package/dist/plugins/uvue/compiler/transforms/vShow.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformShow = void 0;
+const runtimeHelpers_1 = require("../runtimeHelpers");
+const transformShow = (dir, node, context) => {
+    return {
+        props: [],
+        needRuntime: context.helper(runtimeHelpers_1.V_SHOW),
+    };
+};
+exports.transformShow = transformShow;

package/dist/plugins/uvue/compiler/transforms/vText.d.ts

@@ -0,0 +1,2 @@
+import { DirectiveTransform } from '@vue/compiler-core';
+export declare const transformVText: DirectiveTransform;

package/dist/plugins/uvue/compiler/transforms/vText.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVText = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+// import { createDOMCompilerError, DOMErrorCodes } from '../errors'
+const transformVText = (dir, node, context) => {
+    const { exp, loc } = dir;
+    // if (!exp) {
+    //   context.onError(
+    //     createDOMCompilerError(DOMErrorCodes.X_V_TEXT_NO_EXPRESSION, loc)
+    //   )
+    // }
+    // if (node.children.length) {
+    //   context.onError(
+    //     createDOMCompilerError(DOMErrorCodes.X_V_TEXT_WITH_CHILDREN, loc)
+    //   )
+    //   node.children.length = 0
+    // }
+    return {
+        props: [
+            (0, compiler_core_1.createObjectProperty)((0, compiler_core_1.createSimpleExpression)(`value`, true), exp
+                ? (0, compiler_core_1.getConstantType)(exp, context) > 0
+                    ? exp
+                    : (0, compiler_core_1.createCallExpression)(context.helperString(compiler_core_1.TO_DISPLAY_STRING), [exp], loc)
+                : (0, compiler_core_1.createSimpleExpression)('', true)),
+        ],
+    };
+};
+exports.transformVText = transformVText;

package/dist/plugins/uvue/compiler/utils.d.ts

@@ -0,0 +1,5 @@
+import { CompilerOptions } from './options';
+import { ExpressionNode } from '@vue/compiler-core';
+export declare function genRenderFunctionDecl({ targetLanguage, filename, }: CompilerOptions): string;
+export declare const objectExp: RegExp;
+export declare function object2Map(exp: ExpressionNode | string, wrap?: boolean): string;

package/dist/plugins/uvue/compiler/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.object2Map = exports.objectExp = exports.genRenderFunctionDecl = void 0;
+const shared_1 = require("@vue/shared");
+function genRenderFunctionDecl({ targetLanguage, filename, }) {
+    return `${targetLanguage === 'kotlin' ? '@Suppress("UNUSED_PARAMETER") ' : ''}function ${filename}Render(_ctx: ${filename}): VNode | null`;
+}
+exports.genRenderFunctionDecl = genRenderFunctionDecl;
+exports.objectExp = /\{.*\}/g;
+function object2Map(exp, wrap = true) {
+    const content = (0, shared_1.isString)(exp) ? exp : exp.content;
+    const matched = content.match(exports.objectExp)[0];
+    const keyValues = matched.replace(/\{|\}/g, '').split(',');
+    let mapConstructor = wrap ? 'new Map<string, any | null>([' : '';
+    keyValues.forEach((keyValue, index) => {
+        const colonIndex = keyValue.indexOf(':');
+        const key = needAddQuotes(exp, keyValue)
+            ? `'${keyValue.substring(0, colonIndex)}'`
+            : keyValue.substring(0, colonIndex);
+        const value = keyValue.substring(colonIndex + 1);
+        if (key && value) {
+            mapConstructor += `[${key},${value}]`;
+            if (index < keyValues.length - 1) {
+                mapConstructor += ',';
+            }
+        }
+    });
+    mapConstructor += wrap ? '])' : '';
+    return content.replace(matched, mapConstructor);
+}
+exports.object2Map = object2Map;
+function needAddQuotes(exp, keyValue) {
+    return (!(0, shared_1.isString)(exp) &&
+        exp.constType === 3 /* ConstantTypes.CAN_STRINGIFY */ &&
+        !keyValue.startsWith("'") &&
+        !keyValue.startsWith('"'));
+}

package/dist/plugins/uvue/descriptorCache.d.ts

@@ -0,0 +1,24 @@
+import type * as _compiler from '@vue/compiler-sfc';
+import type { CompilerError, SFCDescriptor } from '@vue/compiler-sfc';
+export interface ResolvedOptions {
+    compiler: typeof _compiler;
+    root: string;
+    sourceMap: boolean;
+    targetLanguage?: 'kotlin' | 'swift' | 'javascript';
+    classNamePrefix?: string;
+}
+export interface SFCParseResult {
+    descriptor: SFCDescriptor;
+    errors: Array<CompilerError | SyntaxError>;
+}
+declare module '@vue/compiler-sfc' {
+    interface SFCDescriptor {
+        id: string;
+    }
+}
+export declare function createDescriptor(filename: string, source: string, { root, sourceMap, compiler }: ResolvedOptions): SFCParseResult;
+export declare function getPrevDescriptor(filename: string): SFCDescriptor | undefined;
+export declare function setPrevDescriptor(filename: string, entry: SFCDescriptor): void;
+export declare function getDescriptor(filename: string, options: ResolvedOptions, createIfNotFound?: boolean): SFCDescriptor | undefined;
+export declare function getSrcDescriptor(filename: string): SFCDescriptor;
+export declare function setSrcDescriptor(filename: string, entry: SFCDescriptor): void;

package/dist/plugins/uvue/descriptorCache.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSrcDescriptor = exports.getSrcDescriptor = exports.getDescriptor = exports.setPrevDescriptor = exports.getPrevDescriptor = exports.createDescriptor = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = require("crypto");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const cache = new Map();
+const prevCache = new Map();
+function createDescriptor(filename, source, { root, sourceMap, compiler }) {
+    const { descriptor, errors } = compiler.parse(source, {
+        filename,
+        sourceMap,
+    });
+    // ensure the path is normalized in a way that is consistent inside
+    // project (relative to root) and on different systems.
+    const normalizedPath = (0, uni_cli_shared_1.normalizePath)(path_1.default.normalize(path_1.default.relative(root, filename)));
+    descriptor.id = getHash(normalizedPath);
+    cache.set(filename, descriptor);
+    return { descriptor, errors };
+}
+exports.createDescriptor = createDescriptor;
+function getPrevDescriptor(filename) {
+    return prevCache.get(filename);
+}
+exports.getPrevDescriptor = getPrevDescriptor;
+function setPrevDescriptor(filename, entry) {
+    prevCache.set(filename, entry);
+}
+exports.setPrevDescriptor = setPrevDescriptor;
+function getDescriptor(filename, options, createIfNotFound = true) {
+    if (cache.has(filename)) {
+        return cache.get(filename);
+    }
+    if (createIfNotFound) {
+        const { descriptor, errors } = createDescriptor(filename, fs_1.default.readFileSync(filename, 'utf-8'), options);
+        if (errors.length) {
+            throw errors[0];
+        }
+        return descriptor;
+    }
+}
+exports.getDescriptor = getDescriptor;
+function getSrcDescriptor(filename) {
+    return cache.get(filename);
+}
+exports.getSrcDescriptor = getSrcDescriptor;
+function setSrcDescriptor(filename, entry) {
+    cache.set(filename, entry);
+}
+exports.setSrcDescriptor = setSrcDescriptor;
+function getHash(text) {
+    return (0, crypto_1.createHash)('sha256').update(text).digest('hex').substring(0, 8);
+}

package/dist/plugins/uvue/error.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerError } from '@vue/compiler-sfc';
+import type { RollupError } from 'rollup';
+export declare function createRollupError(id: string, error: CompilerError | SyntaxError): RollupError;

package/dist/plugins/uvue/error.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRollupError = void 0;
+function createRollupError(id, error) {
+    const { message, name, stack } = error;
+    const rollupError = {
+        id,
+        plugin: 'vue',
+        message,
+        name,
+        stack,
+    };
+    if ('code' in error && error.loc) {
+        rollupError.loc = {
+            file: id,
+            line: error.loc.start.line,
+            column: error.loc.start.column,
+        };
+    }
+    return rollupError;
+}
+exports.createRollupError = createRollupError;

package/dist/plugins/uvue/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from 'vite';
+import type { SFCDescriptor, SFCParseResult } from '@vue/compiler-sfc';
+import type { TransformPluginContext } from 'rollup';
+import { ResolvedOptions } from './descriptorCache';
+export declare function uniAppUVuePlugin(): Plugin;
+interface TransformVueResult {
+    errors: SFCParseResult['errors'];
+    uts?: string;
+    js?: string;
+    descriptor: SFCDescriptor;
+}
+export declare function transformVue(code: string, filename: string, options: ResolvedOptions, pluginContext: TransformPluginContext | undefined, isAppVue: ((id: string) => boolean) | undefined, normalizeEasyComSource: (source: string) => string): Promise<TransformVueResult>;
+export {};

package/dist/plugins/uvue/index.js

@@ -0,0 +1,188 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformVue = exports.uniAppUVuePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const descriptorCache_1 = require("./descriptorCache");
+const error_1 = require("./error");
+const utils_1 = require("../utils");
+const script_1 = require("./code/script");
+const template_1 = require("./code/template");
+const style_1 = require("./code/style");
+function resolveAppVue(inputDir) {
+    const appUVue = path_1.default.resolve(inputDir, 'app.uvue');
+    if (fs_extra_1.default.existsSync(appUVue)) {
+        return (0, uni_cli_shared_1.normalizePath)(appUVue);
+    }
+    return (0, uni_cli_shared_1.normalizePath)(path_1.default.resolve(inputDir, 'App.vue'));
+}
+function uniAppUVuePlugin() {
+    const options = {
+        root: process.env.UNI_INPUT_DIR,
+        sourceMap: false,
+        // eslint-disable-next-line no-restricted-globals
+        compiler: require('@vue/compiler-sfc'),
+        targetLanguage: process.env.UNI_UTS_TARGET_LANGUAGE,
+    };
+    const appVue = resolveAppVue(process.env.UNI_INPUT_DIR);
+    function isAppVue(id) {
+        return (0, uni_cli_shared_1.normalizePath)(id) === appVue;
+    }
+    function normalizeEasyComSource(source) {
+        // 把源码source调整为.uvue目录
+        return (0, utils_1.parseUTSImportFilename)(source);
+    }
+    return {
+        name: 'uni:app-uvue',
+        apply: 'build',
+        async resolveId(id) {
+            // serve sub-part requests (*?vue) as virtual modules
+            if ((0, uni_cli_shared_1.parseVueRequest)(id).query.vue) {
+                return id;
+            }
+        },
+        load(id) {
+            const { filename, query } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            // select corresponding block for sub-part virtual modules
+            if (query.vue) {
+                if (query.src) {
+                    return fs_extra_1.default.readFileSync(filename, 'utf-8');
+                }
+                const descriptor = (0, descriptorCache_1.getDescriptor)(filename, options);
+                let block;
+                if (query.type === 'style') {
+                    block = descriptor.styles[query.index];
+                }
+                else if (query.index != null) {
+                    block = descriptor.customBlocks[query.index];
+                }
+                if (block) {
+                    return {
+                        code: block.content,
+                        map: block.map,
+                    };
+                }
+            }
+        },
+        async transform(code, id) {
+            const { filename, query } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            if (!(0, utils_1.isVue)(filename)) {
+                return;
+            }
+            if (!query.vue) {
+                // main request
+                const { errors, uts, js } = await transformVue(code, filename, options, this, isAppVue, normalizeEasyComSource);
+                if (errors.length) {
+                    errors.forEach((error) => this.error((0, error_1.createRollupError)(filename, error)));
+                    return null;
+                }
+                this.emitFile({
+                    type: 'asset',
+                    fileName: (0, utils_1.parseUTSRelativeFilename)(filename),
+                    source: uts,
+                });
+                return {
+                    code: js,
+                };
+            }
+            else {
+                // sub block request
+                const descriptor = query.src
+                    ? (0, descriptorCache_1.getSrcDescriptor)(filename)
+                    : (0, descriptorCache_1.getDescriptor)(filename, options);
+                if (query.type === 'style') {
+                    return (0, style_1.transformStyle)(code, descriptor, Number(query.index), options, this, filename);
+                }
+            }
+        },
+        generateBundle(_, bundle) {
+            // 遍历vue文件，填充style，尽量减少全局变量
+            Object.keys(bundle).forEach((name) => {
+                const file = bundle[name];
+                if (file &&
+                    file.type === 'asset' &&
+                    (0, utils_1.isVue)(file.fileName) &&
+                    (0, shared_1.isString)(file.source)) {
+                    const fileName = (0, uni_cli_shared_1.normalizePath)(file.fileName);
+                    const classNameComment = `/*${(0, utils_1.genClassName)(fileName, options.classNamePrefix)}Styles*/`;
+                    if (file.source.includes(classNameComment)) {
+                        const styleAssetName = fileName + '.style.uts';
+                        const styleAsset = bundle[styleAssetName];
+                        if (styleAsset &&
+                            styleAsset.type === 'asset' &&
+                            (0, shared_1.isString)(styleAsset.source)) {
+                            file.source = file.source.replace(classNameComment, styleAsset.source.replace('export ', ''));
+                            delete bundle[styleAssetName];
+                        }
+                    }
+                }
+            });
+        },
+    };
+}
+exports.uniAppUVuePlugin = uniAppUVuePlugin;
+async function transformVue(code, filename, options, pluginContext, isAppVue = () => false, normalizeEasyComSource) {
+    if (!options.compiler) {
+        options.compiler = require('@vue/compiler-sfc');
+    }
+    // prev descriptor is only set and used for hmr
+    const { descriptor, errors } = (0, descriptorCache_1.createDescriptor)(filename, code, options);
+    if (errors.length) {
+        return { errors, descriptor };
+    }
+    const isApp = isAppVue(filename);
+    const fileName = path_1.default.relative(options.root, filename);
+    const className = (0, utils_1.genClassName)(fileName, options.classNamePrefix);
+    let templateCode = '';
+    let templateImportEasyComponentsCode = '';
+    let templateImportUTSComponentsCode = '';
+    if (!isApp) {
+        const templateResult = (0, template_1.genTemplate)(descriptor, {
+            targetLanguage: options.targetLanguage,
+            mode: 'function',
+            filename: className,
+            prefixIdentifiers: true,
+            sourceMap: true,
+            matchEasyCom: (tag, uts) => {
+                const source = (0, uni_cli_shared_1.matchEasycom)(tag);
+                if (uts && source) {
+                    return normalizeEasyComSource(source);
+                }
+                return source;
+            },
+            parseUTSComponent: uni_cli_shared_1.parseUTSComponent,
+        });
+        templateCode = templateResult.code;
+        templateImportEasyComponentsCode =
+            templateResult.importEasyComponents.join('\n');
+        templateImportUTSComponentsCode =
+            templateResult.importUTSComponents.join('\n');
+    }
+    // 生成 script 文件
+    let utsCode = (0, script_1.genScript)(descriptor, { filename: className }) +
+        '\n' +
+        (0, style_1.genStyle)(descriptor, { filename: fileName, className }) +
+        '\n';
+    utsCode += templateCode;
+    let jsCode = templateImportEasyComponentsCode + '\n' + templateImportUTSComponentsCode;
+    const content = descriptor.script?.content;
+    if (content) {
+        jsCode += await (0, utils_1.parseImports)(content);
+    }
+    if (descriptor.styles.length) {
+        jsCode += '\n' + (await (0, style_1.genJsStylesCode)(descriptor, pluginContext));
+    }
+    jsCode += `\nexport default "${className}"`;
+    return {
+        errors: [],
+        uts: utsCode,
+        js: jsCode,
+        descriptor,
+    };
+}
+exports.transformVue = transformVue;