@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/json/mp/pages.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeMiniProgramAppJson = exports.parseMiniProgramPagesJson = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@vue/shared");
+const json_1 = require("../json");
+const pages_1 = require("../pages");
+const utils_1 = require("./utils");
+const utils_2 = require("../../utils");
+const project_1 = require("./project");
+function parseMiniProgramPagesJson(jsonStr, platform, options = { subpackages: false }) {
+    return parsePagesJson(jsonStr, platform, options);
+}
+exports.parseMiniProgramPagesJson = parseMiniProgramPagesJson;
+function mergeMiniProgramAppJson(appJson, platformJson = {}) {
+    Object.keys(platformJson).forEach((name) => {
+        if (!(0, project_1.isMiniProgramProjectJsonKey)(name) &&
+            !['usingComponents', 'optimization', 'scopedSlotsCompiler'].includes(name)) {
+            appJson[name] = platformJson[name];
+        }
+    });
+}
+exports.mergeMiniProgramAppJson = mergeMiniProgramAppJson;
+function parsePagesJson(jsonStr, platform, { debug, darkmode, networkTimeout, subpackages, windowOptionsMap, tabBarOptionsMap, tabBarItemOptionsMap, } = {
+    subpackages: false,
+}) {
+    const appJson = {
+        pages: [],
+    };
+    const pageJsons = {};
+    const nvuePages = [];
+    // preprocess
+    const pagesJson = (0, json_1.parseJson)(jsonStr, true);
+    if (!pagesJson) {
+        throw new Error(`[vite] Error: pages.json parse failed.\n`);
+    }
+    function addPageJson(pagePath, style) {
+        const filename = path_1.default.join(process.env.UNI_INPUT_DIR, pagePath);
+        if (fs_1.default.existsSync(filename + '.nvue') &&
+            !fs_1.default.existsSync(filename + '.vue')) {
+            nvuePages.push(pagePath);
+        }
+        const windowOptions = {};
+        if (platform === 'mp-baidu') {
+            // 仅百度小程序需要页面配置 component:true
+            // 快手小程序反而不能配置 component:true，故不能统一添加，目前硬编码处理
+            windowOptions.component = true;
+        }
+        pageJsons[pagePath] = (0, shared_1.extend)(windowOptions, (0, utils_1.parseWindowOptions)(style, platform, windowOptionsMap));
+    }
+    // pages
+    (0, pages_1.validatePages)(pagesJson, jsonStr);
+    pagesJson.pages.forEach((page) => {
+        appJson.pages.push(page.path);
+        addPageJson(page.path, page.style);
+    });
+    // subpackages
+    pagesJson.subPackages = pagesJson.subPackages || pagesJson.subpackages;
+    if (pagesJson.subPackages) {
+        if (subpackages) {
+            appJson.subPackages = pagesJson.subPackages.map(({ root, pages, ...rest }) => {
+                return (0, shared_1.extend)({
+                    root,
+                    pages: pages.map((page) => {
+                        addPageJson((0, utils_2.normalizePath)(path_1.default.join(root, page.path)), page.style);
+                        return page.path;
+                    }),
+                }, rest);
+            });
+        }
+        else {
+            pagesJson.subPackages.forEach(({ root, pages }) => {
+                pages.forEach((page) => {
+                    const pagePath = (0, utils_2.normalizePath)(path_1.default.join(root, page.path));
+                    appJson.pages.push(pagePath);
+                    addPageJson(pagePath, page.style);
+                });
+            });
+        }
+    }
+    // window
+    if (pagesJson.globalStyle) {
+        const windowOptions = (0, utils_1.parseWindowOptions)(pagesJson.globalStyle, platform, windowOptionsMap);
+        const { usingComponents } = windowOptions;
+        if (usingComponents) {
+            delete windowOptions.usingComponents;
+            appJson.usingComponents = usingComponents;
+        }
+        else {
+            delete appJson.usingComponents;
+        }
+        appJson.window = windowOptions;
+    }
+    // tabBar
+    if (pagesJson.tabBar) {
+        const tabBar = (0, utils_1.parseTabBar)(pagesJson.tabBar, platform, tabBarOptionsMap, tabBarItemOptionsMap);
+        if (tabBar) {
+            appJson.tabBar = tabBar;
+        }
+    }
+    ;
+    ['preloadRule', 'workers', 'plugins'].forEach((name) => {
+        if ((0, shared_1.hasOwn)(pagesJson, name)) {
+            appJson[name] = pagesJson[name];
+        }
+    });
+    if (debug) {
+        appJson.debug = debug;
+    }
+    if (networkTimeout) {
+        appJson.networkTimeout = networkTimeout;
+    }
+    if (darkmode) {
+        appJson.darkmode = true;
+        appJson.themeLocation = 'theme.json';
+    }
+    return {
+        appJson,
+        pageJsons,
+        nvuePages,
+    };
+}

package/dist/json/mp/project.d.ts

@@ -0,0 +1,14 @@
+interface ParseMiniProgramProjectJsonOptions {
+    template: Record<string, any>;
+    pagesJson: UniApp.PagesJson;
+}
+interface ProjectConfig {
+    appid: string;
+    projectname: string;
+    condition?: {
+        miniprogram?: UniApp.PagesJson['condition'];
+    };
+}
+export declare function isMiniProgramProjectJsonKey(name: string): boolean;
+export declare function parseMiniProgramProjectJson(jsonStr: string, platform: UniApp.PLATFORM, { template, pagesJson }: ParseMiniProgramProjectJsonOptions): ProjectConfig;
+export {};

package/dist/json/mp/project.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMiniProgramProjectJson = exports.isMiniProgramProjectJsonKey = void 0;
+const shared_1 = require("@vue/shared");
+const json_1 = require("../json");
+const projectKeys = [
+    'appid',
+    'setting',
+    'miniprogramRoot',
+    'cloudfunctionRoot',
+    'qcloudRoot',
+    'pluginRoot',
+    'compileType',
+    'libVersion',
+    'projectname',
+    'packOptions',
+    'debugOptions',
+    'scripts',
+    'cloudbaseRoot',
+];
+function isMiniProgramProjectJsonKey(name) {
+    return projectKeys.includes(name);
+}
+exports.isMiniProgramProjectJsonKey = isMiniProgramProjectJsonKey;
+function parseMiniProgramProjectJson(jsonStr, platform, { template, pagesJson }) {
+    const projectJson = JSON.parse(JSON.stringify(template));
+    const manifestJson = (0, json_1.parseJson)(jsonStr);
+    if (manifestJson) {
+        projectJson.projectname = manifestJson.name;
+        const platformConfig = manifestJson[platform];
+        if (platformConfig) {
+            projectKeys.forEach((name) => {
+                if ((0, shared_1.hasOwn)(platformConfig, name)) {
+                    ;
+                    projectJson[name] = platformConfig[name];
+                }
+            });
+        }
+    }
+    // 其实仅开发期间 condition 生效即可，暂不做判断
+    const miniprogram = parseMiniProgramCondition(pagesJson);
+    if (miniprogram) {
+        if (!projectJson.condition) {
+            projectJson.condition = {};
+        }
+        projectJson.condition.miniprogram = miniprogram;
+    }
+    if (!projectJson.appid) {
+        projectJson.appid = 'touristappid';
+    }
+    return projectJson;
+}
+exports.parseMiniProgramProjectJson = parseMiniProgramProjectJson;
+function parseMiniProgramCondition(pagesJson) {
+    const launchPagePath = process.env.UNI_CLI_LAUNCH_PAGE_PATH || '';
+    if (launchPagePath) {
+        return {
+            current: 0,
+            list: [
+                {
+                    id: 0,
+                    name: launchPagePath,
+                    pathName: launchPagePath,
+                    query: process.env.UNI_CLI_LAUNCH_PAGE_QUERY || '', // 启动参数，在页面的onLoad函数里面得到。
+                },
+            ],
+        };
+    }
+    const condition = pagesJson.condition;
+    if (!condition || !(0, shared_1.isArray)(condition.list) || !condition.list.length) {
+        return;
+    }
+    condition.list.forEach(function (item, index) {
+        item.id = item.id || index;
+        if (item.path) {
+            item.pathName = item.path;
+            delete item.path;
+        }
+    });
+    return condition;
+}

package/dist/json/mp/types.d.ts

@@ -0,0 +1,118 @@
+export interface ComponentJson {
+    component: true;
+    usingComponents?: UsingComponents;
+}
+interface ShareWindowOptions {
+    navigationBarBackgroundColor?: string;
+    navigationBarTextStyle?: 'white' | 'black';
+    navigationBarTitleText?: string;
+    navigationStyle?: 'default' | 'custom';
+    backgroundColor?: string;
+    backgroundTextStyle?: 'dark' | 'light';
+    backgroundColorTop?: string;
+    backgroundColorBottom?: string;
+    enablePullDownRefresh?: boolean;
+    onReachBottomDistance?: number;
+    pageOrientation?: 'portrait' | 'landscape' | 'auto';
+}
+declare type Style = 'v2' | string;
+declare type RestartStrategy = 'homePage' | 'homePageAndLatestPage' | string;
+export interface PageWindowOptions extends ShareWindowOptions {
+    component?: true;
+    disableScroll?: boolean;
+    usingComponents?: UsingComponents;
+    initialRenderingCache?: 'static' | string;
+    style?: Style;
+    singlePage?: SinglePage;
+    restartStrategy?: RestartStrategy;
+}
+export interface AppWindowOptions extends ShareWindowOptions {
+    visualEffectInBackground?: 'none' | 'hidden';
+}
+interface SubPackage {
+    name?: string;
+    root: string;
+    pages: string[];
+    independent?: boolean;
+}
+interface TabBarItem {
+    pagePath: string;
+    text: string;
+    iconPath?: string;
+    selectedIconPath?: string;
+}
+export interface TabBar {
+    color: string;
+    selectedColor: string;
+    backgroundColor: string;
+    borderStyle?: 'black' | 'white';
+    list: TabBarItem[];
+    position?: 'bottom' | 'top';
+    custom?: boolean;
+}
+export interface NetworkTimeout {
+    request?: number;
+    requeconnectSocketst?: number;
+    uploadFile?: number;
+    downloadFile?: number;
+}
+interface Plugins {
+    [name: string]: {
+        version: string;
+        provider: string;
+    };
+}
+interface PreloadRule {
+    [name: string]: {
+        network: 'wifi' | 'all';
+        packages: string[];
+    };
+}
+export interface UsingComponents {
+    [name: string]: string;
+}
+interface Permission {
+    [name: string]: {
+        desc: string;
+    };
+}
+interface UseExtendedLib {
+    kbone: boolean;
+    weui: boolean;
+}
+interface EntranceDeclare {
+    locationMessage: {
+        path: string;
+        query: string;
+    };
+}
+interface SinglePage {
+    navigationBarFit?: 'squeezed' | 'float';
+}
+export interface AppJson {
+    entryPagePath?: string;
+    pages: string[];
+    window?: AppWindowOptions;
+    tabBar?: TabBar;
+    networkTimeout?: NetworkTimeout;
+    debug?: boolean;
+    functionalPages?: boolean;
+    subPackages?: SubPackage[];
+    workers?: string;
+    requiredBackgroundModes?: string[];
+    plugins?: Plugins;
+    preloadRule?: PreloadRule;
+    resizable?: boolean;
+    usingComponents?: UsingComponents;
+    permission?: Permission;
+    sitemapLocation?: string;
+    style?: Style;
+    useExtendedLib?: UseExtendedLib;
+    entranceDeclare?: EntranceDeclare;
+    darkmode?: boolean;
+    themeLocation?: string;
+    lazyCodeLoading?: 'requiredComponents' | string;
+    singlePage?: SinglePage;
+    restartStrategy?: RestartStrategy;
+}
+export {};

package/dist/json/mp/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/json/mp/utils.d.ts

@@ -0,0 +1,3 @@
+import { AppWindowOptions, PageWindowOptions, TabBar } from './types';
+export declare function parseWindowOptions(style: UniApp.PagesJsonPageStyle, platform: UniApp.PLATFORM, windowOptionsMap?: Record<string, string>): PageWindowOptions | AppWindowOptions;
+export declare function parseTabBar(tabBar: UniApp.TabBarOptions, platform: UniApp.PLATFORM, tabBarOptionsMap?: Record<string, string>, tabBarItemOptionsMap?: Record<string, string>): TabBar;

package/dist/json/mp/utils.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTabBar = exports.parseWindowOptions = void 0;
+const shared_1 = require("@vue/shared");
+const pages_1 = require("../pages");
+function trimJson(json) {
+    delete json.maxWidth;
+    delete json.topWindow;
+    delete json.leftWindow;
+    delete json.rightWindow;
+    if (json.tabBar) {
+        delete json.tabBar.matchMedia;
+    }
+    return json;
+}
+function convert(to, from, map) {
+    Object.keys(map).forEach((key) => {
+        if ((0, shared_1.hasOwn)(from, map[key])) {
+            to[key] = from[map[key]];
+        }
+    });
+    return to;
+}
+function parseWindowOptions(style, platform, windowOptionsMap) {
+    if (!style) {
+        return {};
+    }
+    const platformStyle = style[platform] || {};
+    (0, pages_1.removePlatformStyle)(trimJson(style));
+    const res = {};
+    if (windowOptionsMap) {
+        return (0, shared_1.extend)(convert(res, style, windowOptionsMap), platformStyle);
+    }
+    return (0, shared_1.extend)(res, style, platformStyle);
+}
+exports.parseWindowOptions = parseWindowOptions;
+function trimTabBarJson(tabBar) {
+    ;
+    [
+        'fontSize',
+        'height',
+        'iconWidth',
+        'midButton',
+        'selectedIndex',
+        'spacing',
+    ].forEach((name) => {
+        delete tabBar[name];
+    });
+    return tabBar;
+}
+function parseTabBar(tabBar, platform, tabBarOptionsMap, tabBarItemOptionsMap) {
+    const platformStyle = tabBar[platform] || {};
+    (0, pages_1.removePlatformStyle)(trimTabBarJson(tabBar));
+    const res = {};
+    if (tabBarOptionsMap) {
+        if (tabBarItemOptionsMap && tabBar.list) {
+            tabBar.list = tabBar.list.map((item) => {
+                return convert({}, item, tabBarItemOptionsMap);
+            });
+        }
+        convert(res, tabBar, tabBarOptionsMap);
+        return (0, shared_1.extend)(res, platformStyle);
+    }
+    return (0, shared_1.extend)(res, tabBar, platformStyle);
+}
+exports.parseTabBar = parseTabBar;

package/dist/json/pages.d.ts

@@ -0,0 +1,30 @@
+export declare function isUniPageFile(file: string, inputDir?: string): boolean;
+export declare function isUniPageSfcFile(file: string, inputDir?: string): boolean;
+/**
+ * 小程序平台慎用，因为该解析不支持 subpackages
+ * @param inputDir
+ * @param platform
+ * @param normalize
+ * @returns
+ */
+export declare const parsePagesJson: (inputDir: string, platform: UniApp.PLATFORM, normalize?: boolean) => UniApp.PagesJson;
+/**
+ * 该方法解析出来的是不支持 subpackages，会被合并入 pages
+ */
+export declare const parsePagesJsonOnce: (inputDir: string, platform: UniApp.PLATFORM, normalize?: boolean) => UniApp.PagesJson;
+/**
+ * 目前 App 和 H5 使用了该方法
+ * @param jsonStr
+ * @param platform
+ * @param param2
+ * @returns
+ */
+export declare function normalizePagesJson(jsonStr: string, platform: UniApp.PLATFORM, { subpackages, }?: {
+    subpackages: boolean;
+}): UniApp.PagesJson;
+export declare function validatePages(pagesJson: Record<string, any>, jsonStr: string): void;
+export declare function removePlatformStyle(pageStyle: Record<string, any>): Record<string, any>;
+export declare function normalizePagesRoute(pagesJson: UniApp.PagesJson): UniApp.UniRoute[];
+declare function parseSubpackagesRoot(inputDir: string, platform: UniApp.PLATFORM): string[];
+export declare const parseSubpackagesRootOnce: typeof parseSubpackagesRoot;
+export {};