@dcloudio/uni-app-uts 3.0.0-3080720230630001

package/dist/plugins/pagesJson.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniAppPagesPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const utils_1 = require("./utils");
+function isPages(id) {
+    return id.endsWith(uni_cli_shared_1.PAGES_JSON_UTS);
+}
+function uniAppPagesPlugin() {
+    const pagesJsonPath = path_1.default.resolve(process.env.UNI_INPUT_DIR, 'pages.json');
+    const pagesJsonUTSPath = path_1.default.resolve(process.env.UNI_INPUT_DIR, uni_cli_shared_1.PAGES_JSON_UTS);
+    let imports = [];
+    let routes = [];
+    let globalStyle = 'new Map()';
+    let tabBar = 'null';
+    return {
+        name: 'uni:app-pages',
+        apply: 'build',
+        resolveId(id) {
+            if (isPages(id)) {
+                return pagesJsonUTSPath;
+            }
+        },
+        load(id) {
+            if (isPages(id)) {
+                return fs_extra_1.default.readFileSync(pagesJsonPath, 'utf8');
+            }
+        },
+        transform(code, id) {
+            if (isPages(id)) {
+                this.addWatchFile(path_1.default.resolve(process.env.UNI_INPUT_DIR, 'pages.json'));
+                const pagesJson = (0, uni_cli_shared_1.normalizeUniAppXAppPagesJson)(code);
+                imports = [];
+                routes = [];
+                pagesJson.pages.forEach((page, index) => {
+                    const className = (0, utils_1.genClassName)(page.path);
+                    let isQuit = index === 0;
+                    imports.push(page.path);
+                    routes.push(`{ path: "${page.path}", component: ${className}Class, meta: { isQuit: ${isQuit} } as PageMeta, style: ${stringifyPageStyle(page.style)}  } as PageRoute`);
+                });
+                if (pagesJson.globalStyle) {
+                    globalStyle = stringifyPageStyle(pagesJson.globalStyle);
+                }
+                if (pagesJson.tabBar) {
+                    tabBar = (0, utils_1.stringifyMap)(pagesJson.tabBar);
+                }
+                return `${imports.map((p) => `import './${p}.uvue'`).join('\n')}
+export default 'pages.json'`;
+            }
+        },
+        generateBundle(_, bundle) {
+            if (bundle[utils_1.ENTRY_FILENAME]) {
+                const asset = bundle[utils_1.ENTRY_FILENAME];
+                asset.source =
+                    asset.source +
+                        `
+${imports
+                            .map((p) => {
+                            const className = (0, utils_1.genClassName)(p);
+                            return `import ${className}Class from './${p}.uvue?type=page'`;
+                        })
+                            .join('\n')}
+function definePageRoutes() {
+${routes.map((route) => `__uniRoutes.push(${route})`).join('\n')}
+}
+function defineAppConfig(){
+  __uniConfig.entryPagePath = '/${imports[0]}'
+  __uniConfig.globalStyle = ${globalStyle}
+  __uniConfig.tabBar = ${tabBar}
+}
+`;
+            }
+        },
+    };
+}
+exports.uniAppPagesPlugin = uniAppPagesPlugin;
+function stringifyPageStyle(pageStyle) {
+    return (0, utils_1.stringifyMap)(pageStyle);
+}

package/dist/plugins/pre.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from 'vite';
+import { FilterPattern } from '@rollup/pluginutils';
+export interface UniPrePluginOptions {
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}
+export declare function uniPrePlugin(options?: UniPrePluginOptions): Plugin;

package/dist/plugins/pre.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniPrePlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const debugPreJs = (0, debug_1.default)('uni:pre-js');
+const debugPreHtml = (0, debug_1.default)('uni:pre-html');
+const debugPreJsTry = (0, debug_1.default)('uni:pre-js-try');
+const PRE_HTML_EXTNAME = ['.vue', '.uvue'];
+const PRE_JS_EXTNAME = ['.json', '.css', '.uts'].concat(PRE_HTML_EXTNAME);
+function uniPrePlugin(options = {}) {
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    const preJsFile = uni_cli_shared_1.preUVueJs;
+    const preHtmlFile = uni_cli_shared_1.preUVueHtml;
+    return {
+        name: 'uni:pre',
+        transform(code, id) {
+            if (!filter(id)) {
+                return;
+            }
+            const { filename } = (0, uni_cli_shared_1.parseVueRequest)(id);
+            const extname = path_1.default.extname(filename);
+            const isHtml = PRE_HTML_EXTNAME.includes(extname);
+            const isJs = PRE_JS_EXTNAME.includes(extname);
+            const isPre = isHtml || isJs;
+            if (isPre) {
+                debugPreJsTry(id);
+            }
+            const hasEndif = isPre && code.includes('#endif');
+            if (!hasEndif) {
+                return;
+            }
+            if (isHtml) {
+                code = preHtmlFile(code);
+                debugPreHtml(id);
+            }
+            if (isJs) {
+                code = preJsFile(code);
+                debugPreJs(id);
+            }
+            return {
+                code,
+            };
+        },
+    };
+}
+exports.uniPrePlugin = uniPrePlugin;

package/dist/plugins/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const ENTRY_FILENAME = "index.uts";
+export declare function parseImports(code: string): Promise<string>;
+export declare function uvueOutDir(): string;
+export declare function genClassName(fileName: string, prefix?: string): string;
+export declare function isVue(filename: string): boolean;
+export declare function stringifyMap(obj: unknown): string;
+export declare function parseUTSRelativeFilename(filename: string): string;
+export declare function parseUTSImportFilename(filename: string): string;

package/dist/plugins/utils.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUTSImportFilename = exports.parseUTSRelativeFilename = exports.stringifyMap = exports.isVue = exports.genClassName = exports.uvueOutDir = exports.parseImports = exports.ENTRY_FILENAME = void 0;
+const path_1 = __importDefault(require("path"));
+const es_module_lexer_1 = require("es-module-lexer");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const shared_1 = require("@vue/shared");
+exports.ENTRY_FILENAME = 'index.uts';
+async function parseImports(code) {
+    await es_module_lexer_1.init;
+    const [imports] = (0, es_module_lexer_1.parse)(code);
+    return imports
+        .map(({ s, e }) => {
+        return `import "${code.slice(s, e)}"`;
+    })
+        .concat(parseUniExtApiImports(code))
+        .join('\n');
+}
+exports.parseImports = parseImports;
+function parseUniExtApiImports(code) {
+    const extApis = (0, uni_cli_shared_1.parseUniExtApiNamespacesJsOnce)(process.env.UNI_UTS_PLATFORM, process.env.UNI_UTS_TARGET_LANGUAGE);
+    const pattern = /uni\.(\w+)/g;
+    const apis = new Set();
+    let match;
+    while ((match = pattern.exec(code)) !== null) {
+        apis.add(match[1]);
+    }
+    const imports = [];
+    apis.forEach((api) => {
+        const extApi = extApis[api];
+        if (extApi) {
+            imports.push(`import "${extApi[0]}"`);
+        }
+    });
+    return imports;
+}
+function uvueOutDir() {
+    return path_1.default.join(process.env.UNI_OUTPUT_DIR, '../.uvue');
+}
+exports.uvueOutDir = uvueOutDir;
+function genClassName(fileName, prefix = 'Gen') {
+    return (prefix +
+        (0, shared_1.capitalize)((0, shared_1.camelize)((0, uni_cli_shared_1.removeExt)((0, uni_cli_shared_1.normalizePath)(fileName).replace(/\//g, '-')))));
+}
+exports.genClassName = genClassName;
+function isVue(filename) {
+    return filename.endsWith('.vue') || filename.endsWith('.uvue');
+}
+exports.isVue = isVue;
+function stringifyMap(obj) {
+    return serialize(obj, true);
+}
+exports.stringifyMap = stringifyMap;
+function serialize(obj, ts = false) {
+    if ((0, shared_1.isString)(obj)) {
+        return `"${obj}"`;
+    }
+    else if ((0, shared_1.isPlainObject)(obj)) {
+        const entries = Object.entries(obj).map(([key, value]) => `[${serialize(key, ts)},${serialize(value, ts)}]`);
+        return `new Map${ts ? '<string, any>' : ''}([${entries.join(',')}])`;
+    }
+    else if ((0, shared_1.isArray)(obj)) {
+        return `[${obj.map((item) => serialize(item, ts)).join(',')}]`;
+    }
+    else {
+        return String(obj);
+    }
+}
+function parseUTSRelativeFilename(filename) {
+    if (!path_1.default.isAbsolute(filename)) {
+        return filename;
+    }
+    return (0, uni_cli_shared_1.normalizeNodeModules)(path_1.default.relative(process.env.UNI_INPUT_DIR, filename));
+}
+exports.parseUTSRelativeFilename = parseUTSRelativeFilename;
+function parseUTSImportFilename(filename) {
+    if (!path_1.default.isAbsolute(filename)) {
+        return filename;
+    }
+    return (0, uni_cli_shared_1.normalizePath)(path_1.default.join(uvueOutDir(), (0, uni_cli_shared_1.normalizeNodeModules)(path_1.default.relative(process.env.UNI_INPUT_DIR, filename))));
+}
+exports.parseUTSImportFilename = parseUTSImportFilename;

package/dist/plugins/uvue/code/script.d.ts

@@ -0,0 +1,4 @@
+import { SFCDescriptor } from '@vue/compiler-sfc';
+export declare function genScript({ script }: SFCDescriptor, _options: {
+    filename: string;
+}): string;

package/dist/plugins/uvue/code/script.js

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

package/dist/plugins/uvue/code/style.d.ts

@@ -0,0 +1,12 @@
+import type { SFCDescriptor } from '@vue/compiler-sfc';
+import type { PluginContext, TransformPluginContext } from 'rollup';
+import { ResolvedOptions } from '../descriptorCache';
+export declare function genStyle(_: SFCDescriptor, { className }: {
+    className: string;
+    filename: 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>;

package/dist/plugins/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;

package/dist/plugins/uvue/code/template.d.ts

@@ -0,0 +1,3 @@
+import { SFCDescriptor } from '@vue/compiler-sfc';
+import { CompilerOptions } from '../compiler/options';
+export declare function genTemplate({ template }: SFCDescriptor, options: CompilerOptions): import("../compiler/options").CodegenResult;

package/dist/plugins/uvue/code/template.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genTemplate = void 0;
+const compiler_1 = require("../compiler");
+const utils_1 = require("../compiler/utils");
+function genTemplate({ template }, options) {
+    if (!template) {
+        return {
+            code: (0, utils_1.genRenderFunctionDecl)(options) + ` { return null }`,
+            importEasyComponents: [],
+            importUTSComponents: [],
+        };
+    }
+    return (0, compiler_1.compile)(template.content, options);
+}
+exports.genTemplate = genTemplate;

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

@@ -0,0 +1,22 @@
+import { SourceMapGenerator } from 'source-map';
+import { JSChildNode, RootNode, SSRCodegenNode, TemplateChildNode } from '@vue/compiler-core';
+import { CodegenOptions, CodegenResult } from './options';
+type CodegenNode = TemplateChildNode | JSChildNode | SSRCodegenNode;
+export interface CodegenContext extends Required<CodegenOptions> {
+    source: string;
+    code: string;
+    importEasyComponents: string[];
+    importUTSComponents: string[];
+    line: number;
+    column: number;
+    offset: number;
+    indentLevel: number;
+    map?: SourceMapGenerator;
+    helper(key: symbol): string;
+    push(code: string, node?: CodegenNode): void;
+    indent(): void;
+    deindent(withoutNewLine?: boolean): void;
+    newline(): void;
+}
+export declare function generate(ast: RootNode, options: CodegenOptions): CodegenResult;
+export {};