2025/2/8第一次更新

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/script.d.ts

@@ -0,0 +1,5 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+export declare function genScript({ script }: SFCDescriptor, { genDefaultAs }: {
+    genDefaultAs?: string;
+}): string;
+export declare function genDefaultScriptCode(genDefaultAs?: string): string;

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/script.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genDefaultScriptCode = exports.genScript = void 0;
+function genScript({ script }, { genDefaultAs }) {
+    if (!script) {
+        return genDefaultScriptCode(genDefaultAs);
+    }
+    return ('\n'.repeat(script.loc.start.line - 1) +
+        `${script.content}
+`);
+}
+exports.genScript = genScript;
+function genDefaultScriptCode(genDefaultAs) {
+    if (genDefaultAs) {
+        return `const ${genDefaultAs} = defineComponent({})
+export default ${genDefaultAs}`;
+    }
+    return `
+export default {}
+`;
+}
+exports.genDefaultScriptCode = genDefaultScriptCode;

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/style.d.ts

@@ -0,0 +1,11 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+import type { PluginContext, TransformPluginContext } from 'rollup';
+import { type ResolvedOptions } from '../descriptorCache';
+export declare function genStyle(_: SFCDescriptor, { className }: {
+    className: string;
+}): string;
+export declare function genJsStylesCode(descriptor: SFCDescriptor, pluginContext: PluginContext): Promise<string>;
+export declare function transformStyle(code: string, descriptor: SFCDescriptor, index: number, options: ResolvedOptions, pluginContext: TransformPluginContext, filename: string): Promise<{
+    code: string;
+    map: null;
+} | null>;

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/style.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStyle = exports.genJsStylesCode = exports.genStyle = void 0;
+const descriptorCache_1 = require("../descriptorCache");
+function genStyle(_, { className }) {
+    return `/*${className}Styles*/`;
+}
+exports.genStyle = genStyle;
+async function genJsStylesCode(descriptor, pluginContext) {
+    let stylesCode = ``;
+    if (descriptor.styles.length) {
+        for (let i = 0; i < descriptor.styles.length; i++) {
+            const style = descriptor.styles[i];
+            if (style.src) {
+                await linkSrcToDescriptor(style.src, descriptor, pluginContext);
+            }
+            const src = style.src || descriptor.filename;
+            // do not include module in default query, since we use it to indicate
+            // that the module needs to export the modules json
+            const attrsQuery = attrsToQuery(style.attrs, 'css');
+            const srcQuery = style.src ? '&src=true' : '';
+            const query = `?vue&type=style&index=${i}${srcQuery}`;
+            const styleRequest = src + query + attrsQuery;
+            stylesCode += `\nimport ${JSON.stringify(styleRequest)}`;
+        }
+    }
+    return stylesCode;
+}
+exports.genJsStylesCode = genJsStylesCode;
+/**
+ * For blocks with src imports, it is important to link the imported file
+ * with its owner SFC descriptor so that we can get the information about
+ * the owner SFC when compiling that file in the transform phase.
+ */
+async function linkSrcToDescriptor(src, descriptor, pluginContext) {
+    const srcFile = (await pluginContext.resolve(src, descriptor.filename))?.id || src;
+    // #1812 if the src points to a dep file, the resolved id may contain a
+    // version query.
+    (0, descriptorCache_1.setSrcDescriptor)(srcFile.replace(/\?.*$/, ''), descriptor);
+}
+// these are built-in query parameters so should be ignored
+// if the user happen to add them as attrs
+const ignoreList = ['id', 'index', 'src', 'type', 'lang', 'module', 'scoped'];
+function attrsToQuery(attrs, langFallback, forceLangFallback = false) {
+    let query = ``;
+    for (const name in attrs) {
+        const value = attrs[name];
+        if (!ignoreList.includes(name)) {
+            query += `&${encodeURIComponent(name)}${value ? `=${encodeURIComponent(value)}` : ``}`;
+        }
+    }
+    if (langFallback || attrs.lang) {
+        query +=
+            `lang` in attrs
+                ? forceLangFallback
+                    ? `&lang.${langFallback}`
+                    : `&lang.${attrs.lang}`
+                : `&lang.${langFallback}`;
+    }
+    return query;
+}
+async function transformStyle(code, descriptor, index, options, pluginContext, filename) {
+    const block = descriptor.styles[index];
+    // vite already handles pre-processors and CSS module so this is only
+    // applying SFC-specific transforms like scoped mode and CSS vars rewrite (v-bind(var))
+    const result = await options.compiler.compileStyleAsync({
+        filename: descriptor.filename,
+        id: `data-v-${descriptor.id}`,
+        isProd: true,
+        source: code,
+    });
+    if (result.errors.length) {
+        result.errors.forEach((error) => {
+            if (error.line && error.column) {
+                error.loc = {
+                    file: descriptor.filename,
+                    line: error.line + block.loc.start.line,
+                    column: error.column,
+                };
+            }
+            pluginContext.error(error);
+        });
+        return null;
+    }
+    return {
+        code: result.code,
+        map: null,
+    };
+}
+exports.transformStyle = transformStyle;

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/template.d.ts

@@ -0,0 +1,8 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+import type { CodegenResult, TemplateCompilerOptions } from '../compiler/options';
+import type { TransformPluginContext } from 'rollup';
+export declare function genTemplate({ template }: SFCDescriptor, options: TemplateCompilerOptions & {
+    genDefaultAs?: string;
+}): CodegenResult;
+export declare const genTemplateCode: typeof genTemplate;
+export declare function tryResolveTemplateSrc(descriptor: SFCDescriptor, pluginContext?: TransformPluginContext): Promise<void>;

node_modules/@dcloudio/uni-app-uts/dist/plugins/android/uvue/code/template.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryResolveTemplateSrc = exports.genTemplateCode = exports.genTemplate = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const compiler_1 = require("../compiler");
+const utils_1 = require("../compiler/utils");
+const descriptorCache_1 = require("../descriptorCache");
+function genTemplate({ template }, options) {
+    if (!template || !template.content) {
+        return {
+            code: options.mode === 'module'
+                ? (0, utils_1.genRenderFunctionDecl)(options) + ` { return null }`
+                : `null`,
+            easyComponentAutoImports: {},
+            preamble: '',
+            elements: [],
+            imports: [],
+        };
+    }
+    const { preprocessLang, preprocessOptions } = options;
+    const preprocessor = preprocessLang
+        ? require('@vue/consolidate')[preprocessLang]
+        : false;
+    return (0, compiler_1.compile)(preprocessor
+        ? preprocess({ source: template.content, filename: '', preprocessOptions }, preprocessor)
+        : template.content, options);
+}
+exports.genTemplate = genTemplate;
+exports.genTemplateCode = genTemplate;
+function preprocess({ source, filename, preprocessOptions, }, preprocessor) {
+    // Consolidate exposes a callback based API, but the callback is in fact
+    // called synchronously for most templating engines. In our case, we have to
+    // expose a synchronous API so that it is usable in Jest transforms (which
+    // have to be sync because they are applied via Node.js require hooks)
+    let res = '';
+    let err = null;
+    preprocessor.render(source, { filename, ...preprocessOptions }, (_err, _res) => {
+        if (_err)
+            err = _err;
+        res = _res;
+    });
+    if (err)
+        throw err;
+    return res;
+}
+async function tryResolveTemplateSrc(descriptor, pluginContext) {
+    if (!pluginContext) {
+        return;
+    }
+    if (!descriptor.template) {
+        return;
+    }
+    if (descriptor.template.src) {
+        const resolved = await pluginContext.resolve(descriptor.template.src, descriptor.filename);
+        if (resolved) {
+            const filename = resolved.id;
+            // 如果引入的vue文件，读取对应的template
+            if ((0, uni_cli_shared_1.isVueSfcFile)(filename)) {
+                const srcDescriptor = (0, descriptorCache_1.getDescriptor)(filename, (0, descriptorCache_1.getResolvedOptions)());
+                if (srcDescriptor && srcDescriptor.template?.content) {
+                    descriptor.template.content = srcDescriptor.template.content;
+                }
+            }
+            else {
+                descriptor.template.content = (0, uni_cli_shared_1.preUVueHtml)(fs_extra_1.default.readFileSync(filename, 'utf-8'));
+            }
+        }
+    }
+}
+exports.tryResolveTemplateSrc = tryResolveTemplateSrc;