@tarojs/plugin-platform-harmony-ets 3.7.0-alpha.27

package/dist/index.js

@@ -0,0 +1,1183 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helper = require('@tarojs/helper');
+var path = require('node:path');
+var runnerUtils = require('@tarojs/runner-utils');
+var shared = require('@tarojs/shared');
+var service = require('@tarojs/service');
+var _package = require('@tarojs/service/dist/utils/package');
+var webpackSources = require('webpack-sources');
+var template = require('@tarojs/shared/dist/template');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+const PLATFORM_NAME = 'harmony';
+const PACKAGE_NAME = '@tarojs/plugin-platform-harmony';
+const PLUGIN_NAME = 'TaroHarmony';
+const HARMONY_SCOPES = [/^@system\./, /^@ohos\./, /^@hmscore\//];
+
+function parseRelativePath(from, to) {
+    const relativePath = path.relative(from, to).replace(/\\/g, '/');
+    return /^\.{1,2}[\\/]/.test(relativePath)
+        ? relativePath
+        : /^\.{1,2}$/.test(relativePath)
+            ? `${relativePath}/`
+            : `./${relativePath}`;
+}
+
+class TaroPlatformHarmony extends service.TaroPlatform {
+    constructor() {
+        super(...arguments);
+        this.platformType = shared.PLATFORM_TYPE.HARMONY;
+        this.globalObject = 'globalThis';
+    }
+    /**
+     * 1. 清空 dist 文件夹
+     * 2. 输出编译提示
+     */
+    setup() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setupTransaction.perform(this.setupHarmonyApp, this);
+            (_b = (_a = this.ctx).onSetupClose) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+        });
+    }
+    setupHarmonyApp() {
+        const { output } = this.config;
+        // eslint-disable-next-line eqeqeq
+        if (output == undefined || output.clean == undefined || output.clean === true) {
+            this.emptyOutputDir();
+        }
+        else if (shared.isObject(output.clean)) {
+            this.emptyOutputDir(output.clean.keep || []);
+        }
+        this.printDevelopmentTip();
+    }
+    printDevelopmentTip() {
+        const tips = [];
+        const { chalk } = this.helper;
+        if (tips.length) {
+            console.log(chalk.yellowBright('Tips:'));
+            tips.forEach((item, index) => console.log(`${chalk.yellowBright(index + 1)}. ${item}`));
+            console.log('\n');
+        }
+    }
+    /**
+     * 返回当前项目内的 runner 包
+     */
+    getRunner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const compilers = ['vite']; // , 'webpack5'
+            const { npm, chalk } = this.helper;
+            const { appPath } = this.ctx.paths;
+            if (compilers.indexOf(this.compiler) === -1) {
+                const errorChalk = chalk.hex('#f00');
+                console.log(errorChalk(`目前 Harmony 平台只支持使用 ${compilers.join(', ')} 编译，请在 config/index.ts 中设置 compiler = ${compilers[0]} 或者 harmony.compiler = ${compilers[0]}`));
+                process.exit(0);
+            }
+            let runnerPkg;
+            switch (this.compiler) {
+                case 'webpack5':
+                    runnerPkg = '@tarojs/webpack5-runner';
+                    break;
+                case 'vite':
+                default:
+                    runnerPkg = '@tarojs/vite-runner';
+            }
+            const runner = yield npm.getNpmPkg(runnerPkg, appPath);
+            return runner.bind(null, appPath);
+        });
+    }
+    /**
+     * 准备 runner 参数
+     * @param extraOptions 需要额外合入 Options 的配置项
+     */
+    getOptions(extraOptions = {}) {
+        const { ctx } = this;
+        const { recursiveMerge } = ctx.helper;
+        const config = recursiveMerge(Object.assign({}, this.config), {
+            env: {
+                FRAMEWORK: JSON.stringify(this.config.framework),
+                TARO_ENV: JSON.stringify(this.platform),
+                TARO_PLATFORM: JSON.stringify(this.platformType),
+                TARO_VERSION: JSON.stringify(_package.getPkgVersion())
+            },
+        });
+        return Object.assign(Object.assign(Object.assign({}, config), { buildAdapter: config.platform, fileType: this.fileType, platformType: this.platformType, useETS: this.useETS, useJSON5: this.useJSON5 }), extraOptions);
+    }
+    /**
+     * 调用 runner 开始编译
+     * @param extraOptions 需要额外传入 runner 的配置项
+     */
+    build(extraOptions = {}) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            (_b = (_a = this.ctx).onBuildInit) === null || _b === void 0 ? void 0 : _b.call(_a, this);
+            yield this.buildTransaction.perform(this.buildHarmonyApp, this, extraOptions);
+        });
+    }
+    buildHarmonyApp(extraOptions = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const runner = yield this.getRunner();
+            const options = this.getOptions(Object.assign({
+                runtimePath: this.runtimePath,
+                taroComponentsPath: this.taroComponentsPath,
+            }, extraOptions));
+            yield runner(options);
+        });
+    }
+    /**
+     * 调用 runner 开启编译
+     */
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setup();
+            yield this.build();
+        });
+    }
+}
+
+var _Harmony_defineConstants;
+const frameworkAlias = {
+    solid: 'solid',
+    vue: 'vue2',
+    vue3: 'vue3',
+};
+let Harmony$1 = class Harmony extends TaroPlatformHarmony {
+    constructor(ctx, config) {
+        super(ctx, config);
+        this.platform = PLATFORM_NAME;
+        this.globalObject = 'globalThis';
+        this.fileType = {
+            templ: '.hml',
+            style: '.css',
+            config: '.json',
+            script: '.js'
+        };
+        this.useETS = true;
+        this.useJSON5 = true;
+        this.runtimePath = [];
+        this.taroComponentsPath = `${PACKAGE_NAME}/dist/components-harmony-ets`;
+        _Harmony_defineConstants.set(this, {});
+        this.extensions = ['.js', '.jsx', '.ts', '.tsx', '.cjs', '.mjs', '.mts', '.vue', '.ets', '.d.ts'];
+        this.excludeLibraries = [];
+        this.externalDeps = [
+            ['@tarojs/components/types', /^@tarojs[\\/]components[\\/]types/],
+            ['@tarojs/components', /^@tarojs[\\/]components([\\/].+)?$/, this.componentLibrary],
+            ['@tarojs/react', /^@tarojs[\\/]react$/],
+            ['@tarojs/runtime', /^@tarojs[\\/]runtime$/, this.runtimeLibrary],
+            ['@tarojs/taro/types', /^@tarojs[\\/]taro[\\/]types/],
+            ['@tarojs/taro', /^@tarojs[\\/]taro$/, this.apiLibrary],
+            ['@tarojs/plugin-framework-react/dist/runtime', /^@tarojs[\\/]plugin-framework-react[\\/]dist[\\/]runtime$/, this.runtimeFrameworkLibrary],
+            ['react', /^react$|react[\\/]cjs/],
+            ['react/jsx-runtime', /^react[\\/]jsx-runtime$/], // Note: React 环境下自动注入，避免重复
+        ];
+        this.setupTransaction.addWrapper({
+            close() {
+                this.modifyViteConfig();
+            },
+        });
+    }
+    get framework() {
+        return this.ctx.initialConfig.framework || 'react';
+    }
+    get aliasFramework() {
+        return frameworkAlias[this.framework] || 'react';
+    }
+    get apiLibrary() {
+        return path__namespace.resolve(__dirname, './apis');
+    }
+    get componentLibrary() {
+        return path__namespace.resolve(__dirname, './components-harmony-ets');
+    }
+    get runtimeLibrary() {
+        return path__namespace.resolve(__dirname, './runtime-ets');
+    }
+    get runtimeFrameworkLibrary() {
+        return path__namespace.resolve(__dirname, `./runtime-framework/${this.aliasFramework}`);
+    }
+    get defineConstants() {
+        var _a, _b;
+        if (!helper.isEmptyObject(__classPrivateFieldGet(this, _Harmony_defineConstants, "f"))) {
+            return __classPrivateFieldGet(this, _Harmony_defineConstants, "f");
+        }
+        (_a = this.config).env || (_a.env = {});
+        (_b = this.config).defineConstants || (_b.defineConstants = {});
+        __classPrivateFieldSet(this, _Harmony_defineConstants, Object.assign({}, this.config.defineConstants), "f");
+        const env = [...Object.entries(this.config.env), ...Object.entries(process.env)];
+        env.forEach(([key, value]) => {
+            __classPrivateFieldGet(this, _Harmony_defineConstants, "f")[`process.env.${key}`] = JSON.stringify(value);
+        });
+    }
+    indexOfLibraries(lib) {
+        return this.externalDeps.findIndex(([_, rgx]) => rgx.test(lib));
+    }
+    removeFromLibraries(lib) {
+        const index = this.indexOfLibraries(lib);
+        if (index > -1) {
+            this.externalDeps.splice(index, 1);
+        }
+    }
+    moveLibraries(lib, target = '', basedir = this.ctx.paths.appPath, sync = false) {
+        if (!lib)
+            return;
+        if (this.excludeLibraries.some(e => typeof e === 'string' ? e === lib : e.test(lib)))
+            return;
+        if (sync) {
+            const { outputRoot } = this.ctx.runOpts.config;
+            const targetPath = path__namespace.join(outputRoot, helper.NODE_MODULES);
+            // FIXME 不支持 alias 配置
+            const libName = lib;
+            lib = helper.resolveSync(lib, {
+                basedir,
+                extensions: this.extensions,
+                mainFields: ['unpkg', ...helper.defaultMainFields],
+                preserveSymlinks: false,
+            }) || '';
+            // Note: 跳过 node 相关或未能找到的依赖
+            if (!lib || !path__namespace.isAbsolute(lib)) {
+                return this.removeFromLibraries(libName);
+            }
+            let ext = path__namespace.extname(lib);
+            const libDir = lib.replace(/.*[\\/]node_modules[\\/]/, '');
+            const basename = path__namespace.basename(lib, ext);
+            if (['.cjs', '.mjs'].includes(ext)) {
+                ext = '.js';
+            }
+            else if (ext === '.mts') {
+                ext = '.ts';
+            }
+            if (ext === '.js') {
+                let typeName = `@types/${libName.replace('@', '').replace(/\//g, '__')}`;
+                let typePath = helper.resolveSync(typeName, {
+                    basedir,
+                    extensions: this.extensions,
+                    mainFields: [...helper.defaultMainFields],
+                });
+                if (!typePath) {
+                    typeName = path__namespace.join(path__namespace.dirname(lib), `${basename}.d.ts`);
+                    typePath = helper.resolveSync(typeName, {
+                        basedir,
+                        extensions: this.extensions,
+                        mainFields: [...helper.defaultMainFields],
+                    });
+                }
+                if (typePath) {
+                    this.moveLibraries(typePath, path__namespace.extname(target)
+                        ? path__namespace.join(path__namespace.dirname(target), `${basename}.d.ts`)
+                        : path__namespace.join(target, `index.d.ts`), basedir);
+                }
+            }
+            if (ext) {
+                const code = helper.fs.readFileSync(lib, { encoding: 'utf8' });
+                if ((/(?:import\s|from\s|require\()['"]([\\/.][^'"\s]+)['"]\)?/g.test(code)
+                    || /\/{3}\s<reference\spath=['"][^'"\s]+['"]\s\/>/g.test(code))
+                    && `${libName}${path__namespace.extname(libDir)}` !== libDir) {
+                    const pkgPath = path__namespace.relative(libName, libDir);
+                    if (new RegExp(`^index(${this.extensions.map(e => e.replace('.', '\\.')).join('|')})$`).test(pkgPath)) {
+                        // Note: 入口为 index 场景
+                        lib = path__namespace.dirname(lib);
+                    }
+                    else if (!/[\\/]/.test(pkgPath)) {
+                        // FIXME: 非 index 入口文件场景，可能存在入口文件引用 index 但该文件被覆盖的情况，需要额外处理
+                        const isDTS = /\.d\.ts$/.test(target);
+                        target = path__namespace.join(target, `index${isDTS ? '.d.ts' : ext}`);
+                    }
+                    else {
+                        // FIXME 多级目录，可能存在入口不为 index 或者引用一级目录文件的情况，需要额外处理
+                        const dir = path__namespace.dirname(pkgPath);
+                        target = path__namespace.join(target, dir);
+                        lib = path__namespace.dirname(lib);
+                    }
+                }
+                else if (path__namespace.isAbsolute(libDir)) {
+                    // Note: 本地 link 的依赖
+                    const isDTS = /\.d\.ts$/.test(target);
+                    target = path__namespace.extname(target)
+                        ? path__namespace.join(path__namespace.dirname(target), `${basename}${ext}`)
+                        : path__namespace.join(target, `index${isDTS ? '.d.ts' : ext}`);
+                }
+                else if (libDir !== path__namespace.relative(targetPath, target)) {
+                    target = path__namespace.join(targetPath, libDir);
+                }
+            }
+        }
+        const stat = helper.fs.lstatSync(lib);
+        if (stat.isDirectory()) {
+            const files = helper.fs.readdirSync(lib);
+            files.forEach((file) => {
+                if (![helper.NODE_MODULES].includes(file)) {
+                    this.moveLibraries(path__namespace.join(lib, file), path__namespace.join(target, file));
+                }
+            });
+        }
+        else if (stat.isFile()) {
+            let code = helper.fs.readFileSync(lib, { encoding: 'utf8' });
+            if (this.extensions.includes(path__namespace.extname(lib))) {
+                code = code.replace(/(?:import\s|from\s|require\()['"]([^.][^'"\s]+)['"]\)?/g, (src, p1) => {
+                    const { outputRoot } = this.ctx.runOpts.config;
+                    const targetPath = path__namespace.join(outputRoot, helper.NODE_MODULES, p1);
+                    const relativePath = parseRelativePath(path__namespace.dirname(target), targetPath);
+                    if (HARMONY_SCOPES.every(e => !e.test(p1))) {
+                        if (this.indexOfLibraries(p1) === -1) {
+                            this.externalDeps.push([p1, new RegExp(`^${p1.replace(/([-\\/$])/g, '\\$1')}$`)]);
+                            this.moveLibraries(p1, targetPath, path__namespace.dirname(lib), true);
+                        }
+                        return src.replace(p1, relativePath.replace(new RegExp(`\\b${helper.NODE_MODULES}\\b`), 'npm'));
+                    }
+                    return src;
+                });
+                const define = Object.assign({}, this.defineConstants);
+                if ([/(@tarojs[\\/]runtime|taro-runtime)[\\/]dist/].some(e => e.test(lib))) {
+                    define.global = 'globalThis';
+                }
+                code = this.replaceDefineValue(code, define);
+                const ext = path__namespace.extname(target);
+                if (['.ts'].includes(ext)) {
+                    code = '// @ts-nocheck\n' + code;
+                }
+            }
+            if (/tarojs[\\/]taro[\\/]types[\\/]index.d.ts/.test(target)) {
+                code = `/// <reference path="global.d.ts" />
+
+/// <reference path="taro.api.d.ts" />
+/// <reference path="taro.component.d.ts" />
+/// <reference path="taro.config.d.ts" />
+/// <reference path="taro.lifecycle.d.ts" />
+
+export = Taro
+export as namespace Taro
+
+declare const Taro: Taro.TaroStatic
+
+declare namespace Taro {
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  interface TaroStatic {}
+}
+declare global {
+  const defineAppConfig: (config: Taro.Config) => Taro.Config
+  const definePageConfig: (config: Taro.Config) => Taro.Config
+}`;
+            }
+            try {
+                const targetPath = target.replace(new RegExp(`\\b${helper.NODE_MODULES}\\b`), 'npm');
+                helper.fs.ensureDirSync(path__namespace.dirname(targetPath));
+                helper.fs.writeFileSync(targetPath, code);
+            }
+            catch (e) {
+                console.error(`[taro-arkts] inject ${lib} to ${target} failed`, e);
+            }
+        }
+        else if (stat.isSymbolicLink()) {
+            const realPath = helper.fs.realpathSync(lib, { encoding: 'utf8' });
+            this.moveLibraries(realPath, target, basedir);
+        }
+    }
+    replaceDefineValue(code, define) {
+        Object.keys(define).forEach(key => {
+            code = code.replace(new RegExp(`\\b${key}\\b`, 'g'), define[key]);
+        });
+        return code;
+    }
+    /**
+     * 修改 Vite 配置
+     */
+    modifyViteConfig() {
+        var _a, _b;
+        const that = this;
+        const { appPath } = that.ctx.paths;
+        const { config } = that.ctx.runOpts;
+        const { outputRoot } = config;
+        if (!that.framework.includes('vue')) {
+            that.excludeLibraries.push(/\bvue\b/);
+        }
+        // @ts-ignore
+        if (that.framework === 'solid') {
+            that.externalDeps.push([
+                '@tarojs/plugin-framework-react/dist/runtime/reconciler',
+                /^@tarojs\/plugin-framework-react\/dist\/runtime\/reconciler$/,
+                path__namespace.join(this.runtimeFrameworkLibrary, 'reconciler')
+            ]);
+            that.externalDeps.push([
+                'solid-js/universal',
+                /^solid-js\/universal$/,
+            ]);
+        }
+        function modifyResolveId({ source = '', importer = '', options = {}, name = 'modifyResolveId', resolve }) {
+            if (shared.isFunction(resolve)) {
+                if (source === that.runtimePath || that.runtimePath.includes(source)) {
+                    return resolve('@tarojs/runtime', importer, options);
+                }
+            }
+            // Note: 映射 Taro 相关依赖到注入 taro 目录
+            if (that.indexOfLibraries(source) > -1) {
+                return {
+                    external: 'resolve',
+                    id: path__namespace.join(outputRoot, 'npm', source),
+                    moduleSideEffects: false,
+                    resolvedBy: name,
+                };
+            }
+        }
+        (_b = (_a = that.ctx).modifyViteConfig) === null || _b === void 0 ? void 0 : _b.call(_a, ({ viteConfig }) => {
+            function externalPlugin() {
+                const name = 'taro:vite-harmony-external';
+                return {
+                    name,
+                    enforce: 'pre',
+                    resolveId(source = '', importer = '', options = {}) {
+                        return modifyResolveId({
+                            source,
+                            importer,
+                            options,
+                            name,
+                            resolve: this.resolve,
+                        });
+                    },
+                };
+            }
+            function injectLoaderMeta() {
+                return {
+                    name: 'taro:vite-h5-loader-meta',
+                    buildStart() {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            yield this.load({ id: runnerUtils.VITE_COMPILER_LABEL });
+                            const info = this.getModuleInfo(runnerUtils.VITE_COMPILER_LABEL);
+                            const compiler = info === null || info === void 0 ? void 0 : info.meta.viteCompilerContext;
+                            if (compiler) {
+                                switch (that.framework) {
+                                    // @ts-ignore
+                                    case 'solid':
+                                        compiler.loaderMeta || (compiler.loaderMeta = {});
+                                        compiler.loaderMeta.importFrameworkStatement = ``;
+                                        compiler.mockAppStatement = `
+function App(props) {
+  return null
+}
+`;
+                                        compiler.loaderMeta.frameworkArgs = `config`;
+                                        compiler.loaderMeta.creator = `createSolidApp`;
+                                        compiler.loaderMeta.importFrameworkName = '';
+                                        break;
+                                }
+                                compiler.loaderMeta.modifyResolveId = modifyResolveId;
+                            }
+                        });
+                    },
+                };
+            }
+            const targetPath = path__namespace.join(outputRoot, helper.NODE_MODULES);
+            // Note: 注入 Taro 相关依赖
+            this.externalDeps.forEach(([libName, _, target]) => {
+                this.moveLibraries(target || libName, path__namespace.resolve(targetPath, libName), appPath, !target);
+            });
+            viteConfig.plugins.push(externalPlugin(), injectLoaderMeta());
+        });
+    }
+};
+_Harmony_defineConstants = new WeakMap();
+
+const components = {
+    Checkbox: {
+        'group-id': '',
+        cn: ''
+    },
+    Span: {},
+    Tabs: {
+        index: '0',
+        vertical: 'false',
+        bindchange: ''
+    },
+    TabBar: {
+        mode: shared.singleQuote('scrollable')
+    },
+    TabContent: {
+        scrollable: 'true'
+    },
+    List: {
+        scrollpage: 'false',
+        cachedcount: '0',
+        scrollbar: 'off',
+        scrolleffect: shared.singleQuote('spring'),
+        indexer: 'false',
+        indexercircle: '',
+        indexermulti: 'false',
+        indexerbubble: 'true',
+        divider: 'false',
+        shapemode: shared.singleQuote('default'),
+        itemscale: 'true',
+        itemcenter: 'false',
+        updateeffect: 'false',
+        chainanimation: 'false',
+        scrollvibrate: 'true',
+        initialindex: '0',
+        initialoffset: '0',
+        selected: '',
+        bindindexerchange: '',
+        bindscroll: '',
+        bindscrollbottom: '',
+        bindscrolltop: '',
+        bindscrollend: '',
+        bindscrolltouchup: '',
+        bindrequestitem: ''
+    },
+    ListItem: {
+        type: shared.singleQuote('default'),
+        primary: 'false',
+        section: '',
+        sticky: shared.singleQuote('none'),
+        stickyradius: shared.singleQuote('1000px'),
+        clickeffect: 'true',
+        bindsticky: ''
+    },
+    Switch: {
+        showtext: 'false',
+        texton: shared.singleQuote('On'),
+        textoff: shared.singleQuote('Off')
+    },
+    Textarea: {
+        headericon: '',
+        showcounter: 'false',
+        menuoptions: '[]',
+        softkeyboardenabled: 'true',
+        bindtranslate: '',
+        bindshare: '',
+        bindsearch: '',
+        bindoptionselect: '',
+        bindselectchange: ''
+    },
+    Progress: {
+        'active-color': shared.singleQuote('#09BB07'),
+        'background-color': shared.singleQuote('#EBEBEB'),
+        type: shared.singleQuote('horizontal'),
+        'font-size': shared.singleQuote('25px'),
+        secondarypercent: '0',
+        clockwise: 'true'
+    },
+    Slider: {
+        showsteps: 'false',
+        showtips: 'false'
+    },
+    Input: {
+        'placeholder-color': shared.singleQuote('#99000000')
+    },
+    Video: {
+        speed: '1',
+        bindloadedmetadata: '',
+        bindprogress: '',
+        bindtap: ''
+    },
+    Image: {
+        alt: ''
+    },
+    Radio: {
+        'group-id': ''
+    },
+    Picker: {
+        selected: '',
+        hours: '',
+        containsecond: 'false',
+        vibrate: 'true',
+        lunar: 'false',
+        lunarswitch: 'false'
+    },
+    PickerView: {
+        mode: '',
+        range: '',
+        selected: '',
+        hours: '',
+        indicatorprefix: '',
+        indicatorsuffix: '',
+        containsecond: 'false',
+        vibrate: 'true',
+        lunar: 'false',
+        lunarswitch: 'false',
+        bindcolumnchange: '',
+        cn: ''
+    }
+};
+
+class Template extends template.RecursiveTemplate {
+    constructor() {
+        super();
+        this.Adapter = {
+            if: 'if',
+            else: 'else',
+            elseif: 'elif',
+            for: 'for',
+            forItem: 'for-item',
+            forIndex: 'for-index',
+            key: 'key',
+            type: 'harmony'
+        };
+        this.usedNativeComps = [];
+        this.patchVoidElements = [
+            'button',
+            'image',
+            'camera',
+            'video',
+            'web-view',
+            'picker',
+            'checkbox',
+            'rich-text'
+        ];
+        this.buildHeaderTemplate = (componentConfig) => {
+            if (componentConfig.includeAll) {
+                this.usedNativeComps = [...this.nativeComps];
+            }
+            else {
+                this.usedNativeComps = Array.from(componentConfig.includes).filter(name => this.nativeComps.includes(name));
+            }
+            const elements = this.usedNativeComps.reduce((str, name) => str + `<element name="taro-${name}" src="./components-harmony/${name}/index.hml"></element>\n`, '');
+            return `<element name="container" src="./index.hml"></element>
+${elements}
+
+<block>
+`;
+        };
+        this.buildTemplate = (componentConfig) => {
+            let template = this.buildHeaderTemplate(componentConfig);
+            if (!this.miniComponents) {
+                this.componentsAlias = shared.getComponentsAlias(this.internalComponents);
+                this.miniComponents = this.createMiniComponents(this.internalComponents);
+            }
+            const ZERO_FLOOR = 0;
+            const components = Object.keys(this.miniComponents)
+                .filter(c => componentConfig.includes.size && !componentConfig.includeAll ? componentConfig.includes.has(c) : true);
+            template = components.reduce((current, nodeName) => {
+                const attributes = this.miniComponents[nodeName];
+                const nodeAlias = this.componentsAlias[nodeName]._num;
+                return current + this.buildComponentTemplate({ nodeName, nodeAlias, attributes }, ZERO_FLOOR);
+            }, template);
+            template += this.buildPlainTextTemplate();
+            template += '\n</block>';
+            return template;
+        };
+        this.buildPageTemplate = (baseTempPath) => {
+            const containerPath = path.join(path.dirname(baseTempPath), 'container');
+            const containerTempPath = path.join(containerPath, 'index.hml');
+            const navbarTempPath = path.join(containerPath, 'components-harmony/navbar/index.hml');
+            const tabbarTempPath = path.join(containerPath, 'components-harmony/tabbar/index.hml');
+            const template = `<element name="container" src="${containerTempPath}"></element>
+<element name="navbar" src="${navbarTempPath}"></element>
+<element name="tabbar" src="${tabbarTempPath}"></element>
+
+<div class="container">
+  <navbar if="{{taroNavBar}}" title="{{taroNavBar.title}}" background="{{taroNavBar.background}}" text-style="{{taroNavBar.textStyle}}" st="{{taroNavBar.style}}"></navbar>
+  <div class="body" style="padding-top: 44vp;padding-bottom: {{isShowTaroTabBar ? '56vp' : '0'}}">
+    <refresh if="{{enablePullDownRefresh}}" type="pulldown" refreshing="{{isRefreshing}}" onrefresh="onPullDownRefresh">
+      <block for="{{root.cn}}">
+        <container i="{{$item}}"></container>
+      </block>
+    </refresh>
+    <block else for="{{root.cn}}">
+      <container i="{{$item}}"></container>
+    </block>
+  </div>
+  <tabbar if="{{isShowTaroTabBar}}" tabbar-data="{{taroTabBar}}" selected="{{selected}}"></tabbar>
+</div>
+`;
+            return template;
+        };
+        const compsDir = path.resolve(__dirname, 'components-harmony');
+        this.patchVoidElements.forEach(item => {
+            this.voidElements.add(item);
+        });
+        this.nativeComps = helper.fs.readdirSync(compsDir).filter(name => helper.fs.pathExistsSync(path.resolve(compsDir, name, 'index.hml')));
+    }
+    createMiniComponents(components) {
+        components.Button.cn = '';
+        components.Button.bindtap = '';
+        components.Button.type = "'default'";
+        const result = super.createMiniComponents(components);
+        delete result['pure-view'];
+        delete result['static-view'];
+        delete result['static-text'];
+        delete result['static-image'];
+        return result;
+    }
+    buildFocusComponentTemplate(comp) {
+        return this.generateComponentTemplateSrc(comp);
+    }
+    buildStandardComponentTemplate(comp) {
+        let nodeName = '';
+        switch (comp.nodeName) {
+            case 'slot':
+            case 'slot-view':
+            case 'cover-view':
+            case 'view':
+            case 'swiper-item':
+                nodeName = 'div';
+                break;
+            case 'static-text':
+                nodeName = 'text';
+                break;
+            case 'static-image':
+                nodeName = 'image';
+                break;
+            default:
+                nodeName = comp.nodeName;
+                break;
+        }
+        return this.generateComponentTemplateSrc(comp, nodeName);
+    }
+    generateComponentTemplateSrc(comp, nodeName) {
+        const nodeAlias = comp.nodeAlias;
+        const children = this.voidElements.has(comp.nodeName)
+            ? ''
+            : `<block for="{{i.cn}}">
+      <container i="{{$item}}"></container>
+    </block>`;
+        if (!nodeName) {
+            nodeName = comp.nodeName;
+        }
+        if (this.nativeComps.includes(nodeName)) {
+            nodeName = `taro-${nodeName}`;
+        }
+        const res = `
+<block if="{{i.nn == '${nodeAlias}'}}">
+  <${nodeName} ${this.buildAttrs(comp.attributes, comp.nodeName)} id="{{i.uid||i.sid}}" data-sid="{{i.sid}}">
+    ${children}
+  </${nodeName}>
+</block>
+`;
+        return res;
+    }
+    buildPlainTextTemplate() {
+        return `
+<block if="{{i.nn === '#text'}}">
+  <span>{{i.${"v" /* Shortcuts.Text */}}}</span>
+</block>
+`;
+    }
+    buildAttrs(attrs, nodeName) {
+        return Object.keys(attrs)
+            .map(k => `${k}="${k.startsWith('bind') || k.startsWith('on') || k.startsWith('catch') ? attrs[k] : `{${this.getAttrValue(attrs[k], k, nodeName)}}`}" `)
+            .join('');
+    }
+    replacePropName(name, value, componentName) {
+        if (value === 'eh')
+            return name.toLowerCase().replace(/^bind/, '@');
+        // 由于鸿蒙不支持for属性 需要修改for属性，需要改名
+        if (componentName === 'label' && name === 'for')
+            return 'target';
+        return name;
+    }
+    getEvents() {
+        return {
+            '@click': 'eh'
+        };
+    }
+}
+
+const EXPORT_PREFIX = 'var __webpack_exports__ = ';
+class Harmony extends service.TaroPlatformBase {
+    /**
+     * 1. setupTransaction - init
+     * 2. setup
+     * 3. setupTransaction - close
+     * 4. buildTransaction - init
+     * 5. build
+     * 6. buildTransaction - close
+     */
+    constructor(ctx, config) {
+        super(ctx, config);
+        this.platform = 'harmony';
+        this.globalObject = 'globalThis';
+        this.runtimePath = `${PACKAGE_NAME}/dist/runtime`;
+        this.taroComponentsPath = `${PACKAGE_NAME}/dist/components/components-react`;
+        this.fileType = {
+            templ: '.hml',
+            style: '.css',
+            config: '.json',
+            script: '.js'
+        };
+        this.template = new Template();
+        this.addEntry();
+        this.setupTransaction.addWrapper({
+            close() {
+                this.modifyComponents();
+                this.modifyPostcssConfigs(config);
+                this.modifyWebpackConfig();
+            }
+        });
+        this.modifyTaroExport();
+        this.modifyBuildAssets(ctx, config);
+    }
+    /**
+     * 增加组件或修改组件属性
+     */
+    modifyComponents() {
+        this.template.mergeComponents(this.ctx, components);
+    }
+    /**
+     * 不需要转 rpx
+     */
+    modifyPostcssConfigs(config) {
+        config.postcss || (config.postcss = {});
+        const postcssConfig = config.postcss;
+        postcssConfig.autoprefixer = {
+            enable: false
+        };
+    }
+    /**
+     * 模板自定义组件 js
+     * 等鸿蒙支持 template 后需要重构
+     */
+    addEntry() {
+        this.ctx.onCompilerMake(({ compilation, plugin }) => __awaiter(this, void 0, void 0, function* () {
+            // container/index.hml
+            const filePath = path.resolve(__dirname, 'template/container');
+            plugin.addEntry(filePath, 'container/index', helper.META_TYPE.STATIC);
+            const dep = plugin.dependencies.get(filePath);
+            yield new Promise((resolve, reject) => {
+                compilation.addEntry(plugin.options.sourceDir, dep, dep.name, err => err ? reject(err) : resolve(null));
+            });
+        }));
+    }
+    /**
+     * 把 app、pages、自定义组件的 js 改造为鸿蒙的 export default 导出形式
+     */
+    modifyTaroExport() {
+        this.ctx.onCompilerMake(({ compilation, compiler }) => {
+            const render = this.compiler === 'webpack5'
+                ? compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation).render
+                : compilation.chunkTemplate.hooks.renderWithEntry;
+            render.tap(PLUGIN_NAME, (modules, renderContext) => {
+                var _a, _b;
+                const chunk = (_a = renderContext.chunk) !== null && _a !== void 0 ? _a : renderContext; // Webpack4 中 renderContext 实际为 chunk
+                const chunkEntryModule = this.getChunkEntryModule(compilation, chunk, this.compiler);
+                if (chunkEntryModule) {
+                    const entryModule = (_b = chunkEntryModule.rootModule) !== null && _b !== void 0 ? _b : chunkEntryModule;
+                    if (this.checkMetaType(entryModule)) {
+                        const origin = modules._value ? modules._value.toString() : modules.source();
+                        const editedOrigin = origin.replace(/\(globalThis/, 'var taroExport = (globalThis');
+                        const source = new webpackSources.ConcatSource();
+                        source.add(editedOrigin);
+                        source.add(';');
+                        source.add(`\nexport default taroExport ? taroExport.default${entryModule.miniType === helper.META_TYPE.STATIC ? '' : '()'} : {};`);
+                        return source;
+                    }
+                }
+                return modules;
+            });
+            if (this.compiler === 'webpack5') {
+                compilation.hooks.optimizeChunks.tap(PLUGIN_NAME, (chunks) => {
+                    var _a;
+                    for (const chunk of chunks) {
+                        const { chunkGraph, moduleGraph } = compilation;
+                        const chunkEntryModule = this.getChunkEntryModule(compilation, chunk, this.compiler);
+                        if (chunkEntryModule) {
+                            const entryModule = (_a = chunkEntryModule.rootModule) !== null && _a !== void 0 ? _a : chunkEntryModule;
+                            const modulesIterable = chunkGraph.getOrderedChunkModulesIterable(chunk, compiler.webpack.util.comparators.compareModulesByIdentifier);
+                            if (this.checkMetaType(entryModule)) {
+                                for (const module of modulesIterable) {
+                                    const moduleUsedExports = moduleGraph.getUsedExports(module, chunk.runtime);
+                                    if (moduleUsedExports instanceof Set) {
+                                        if (module.identifier().includes(chunk.name)) {
+                                            const exportsInfo = moduleGraph.getExportsInfo(module);
+                                            const used = exportsInfo.getUsedName('default', chunk.runtime);
+                                            if (used) {
+                                                exportsInfo.setUsedWithoutInfo(chunk.runtime);
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+                compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation).renderChunk.tap(PLUGIN_NAME, (modules, renderContext) => {
+                    var _a, _b;
+                    const chunk = (_a = renderContext.chunk) !== null && _a !== void 0 ? _a : renderContext;
+                    const chunkEntryModule = this.getChunkEntryModule(compilation, chunk, this.compiler);
+                    if (chunkEntryModule) {
+                        const entryModule = (_b = chunkEntryModule.rootModule) !== null && _b !== void 0 ? _b : chunkEntryModule;
+                        if (this.checkMetaType(entryModule)) {
+                            // @ts-ignore
+                            const origin = modules._value ? modules._value.toString() : modules.source();
+                            const editedOrigin = origin.replace(EXPORT_PREFIX, 'return ');
+                            const source = new webpackSources.ConcatSource();
+                            source.add(editedOrigin);
+                            return source;
+                        }
+                    }
+                    return modules;
+                });
+            }
+        });
+    }
+    /**
+     * 修改最终的编译产物
+     * 1. 生成模板自定义组件的 xml、css 文件
+     * 2. 删除多余的文件
+     * 3. 把 components-harmony 中被使用到的组件移动到输出目录
+     */
+    modifyBuildAssets(ctx, config) {
+        ctx.modifyBuildAssets(({ assets, miniPlugin }) => {
+            const scriptExt = miniPlugin.options.fileType.script;
+            const templateExt = miniPlugin.options.fileType.templ;
+            const styleExt = miniPlugin.options.fileType.style;
+            const configExt = miniPlugin.options.fileType.config;
+            // 模板自定义组件 xml
+            const base = `base${templateExt}`;
+            assets[`container/index${templateExt}`] = assets[base];
+            delete assets[base];
+            // 模板自定义组件 css
+            const styles = Object.keys(assets).filter(key => key.endsWith(styleExt));
+            const source = new webpackSources.ConcatSource();
+            styles.forEach(file => {
+                const re = path.relative('container', file);
+                source.add(`@import '${re}';\n`);
+            });
+            assets[`container/index${styleExt}`] =
+                this.compiler === 'webpack5'
+                    ? new webpackSources.RawSource(`${source.source()}`)
+                    : {
+                        size: () => source.source().length,
+                        source: () => source.source()
+                    };
+            // 不需要生成 json 配置文件
+            miniPlugin.pages.forEach(page => {
+                delete assets[`${page.name}${configExt}`];
+            });
+            const appConfig = `app${configExt}`;
+            // 修改 harmony Hap 的配置文件 config.json，主要是注入路由配置
+            const route = JSON.parse(assets[appConfig].source()).pages;
+            this.modifyHarmonyConfig(route, config.harmony);
+            // 不需要生成 app.json
+            delete assets[appConfig];
+            // 不需要生成 custom-wrapper
+            delete assets[`custom-wrapper${scriptExt}`];
+            delete assets[`custom-wrapper${templateExt}`];
+            delete assets[`custom-wrapper${configExt}`];
+            // 其他冗余文件
+            delete assets[`container/global${scriptExt}`];
+        });
+        // 把 components-harmony 中被使用到的组件移动到输出目录
+        ctx.onBuildFinish(() => {
+            const outDir = path.resolve(process.cwd(), config.outputRoot);
+            const compsDir = path.resolve(__dirname, '..', 'components', 'components-harmony');
+            const compsOutDir = path.join(outDir, 'container/components-harmony');
+            helper.fs.ensureDirSync(compsOutDir);
+            [...this.template.usedNativeComps, 'navbar', 'tabbar', 'utils'].forEach(name => {
+                const src = path.join(compsDir, name);
+                const outDir = path.join(compsOutDir, name);
+                helper.fs.copy(src, outDir);
+            });
+            this.modifyHostPackageDep(outDir);
+        });
+    }
+    modifyWebpackConfig() {
+        this.ctx.modifyWebpackChain(({ chain }) => {
+            const externals = ({ request }, callback) => {
+                // Note: 判断引用的依赖是否是 Harmony 全局注入的依赖，如果是则 Webpack 不需要处理，直接 external 掉
+                if (this.isHarmonyRequest(request)) {
+                    return callback(null, 'commonjs ' + request);
+                }
+                callback();
+            };
+            chain.merge({
+                externals: [
+                    this.compiler === 'webpack5'
+                        ? externals
+                        : (_context, request, callback) => externals({ request }, callback)
+                ]
+            });
+            chain.plugin('miniPlugin')
+                .tap(args => {
+                args[0].loaderMeta.modifyInstantiate = function (origin) {
+                    return origin.replace(/var inst = (App|Page)\(([A-Za-z]+)\(/, 'export default ($2.bind(null, ');
+                };
+                return args;
+            });
+        });
+    }
+    modifyHarmonyConfig(pages, { projectPath, hapName, name }) {
+        var _a, _b;
+        const designWidth = this.config.designWidth || ((_b = (_a = this.config.postcss.pxtransform) === null || _a === void 0 ? void 0 : _a.config) === null || _b === void 0 ? void 0 : _b.designWidth) || 750;
+        const hapConfigPath = path.join(projectPath, hapName, 'src/main/config.json');
+        helper.fs.readJson(hapConfigPath)
+            .then(config => {
+            var _a;
+            (_a = config.module).js || (_a.js = []);
+            const jsFAs = config.module.js;
+            const target = jsFAs.find(item => item.name === name);
+            if (target) {
+                if (JSON.stringify(target.pages) === JSON.stringify(pages))
+                    return;
+                target.pages = pages;
+                target.window = {
+                    designWidth,
+                    autoDesignWidth: false
+                };
+            }
+            else {
+                jsFAs.push({
+                    pages,
+                    name,
+                    window: {
+                        designWidth,
+                        autoDesignWidth: false
+                    }
+                });
+            }
+            return helper.fs.writeJson(hapConfigPath, config, { spaces: 2 });
+        })
+            .catch(err => {
+            console.warn(helper.chalk.red('设置鸿蒙 Hap 配置失败：', err));
+        });
+    }
+    modifyHostPackageDep(dest) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hmsDeps = {
+                '@hmscore/hms-js-base': '^6.1.0-300',
+                '@hmscore/hms-jsb-account': '^1.0.300'
+            };
+            const packageJsonFile = path.resolve(dest, '../../../../../package.json');
+            const isExists = yield helper.fs.pathExists(packageJsonFile);
+            if (!isExists)
+                return;
+            const data = yield helper.fs.readFile(packageJsonFile);
+            let packageJson = data.toString();
+            packageJson = JSON.parse(packageJson);
+            if (!packageJson.dependencies) {
+                packageJson.dependencies = hmsDeps;
+            }
+            else {
+                for (const hmsDep in hmsDeps) {
+                    packageJson.dependencies[hmsDep] = hmsDeps[hmsDep];
+                }
+            }
+            packageJson = JSON.stringify(packageJson);
+            yield helper.fs.writeFile(packageJsonFile, packageJson);
+        });
+    }
+    getChunkEntryModule(compilation, chunk, compiler = 'webpack4') {
+        if (compiler === 'webpack5') {
+            const chunkGraph = compilation.chunkGraph;
+            const entryModules = Array.from(chunkGraph.getChunkEntryModulesIterable(chunk));
+            if (entryModules.length) {
+                return entryModules[0];
+            }
+        }
+        else {
+            return chunk.entryModule;
+        }
+    }
+    checkMetaType(entryModule) {
+        const { miniType } = entryModule;
+        return miniType === helper.META_TYPE.ENTRY ||
+            miniType === helper.META_TYPE.PAGE ||
+            (miniType === helper.META_TYPE.STATIC && entryModule.name === 'container/index');
+    }
+    isHarmonyRequest(request) {
+        return HARMONY_SCOPES.some(scope => scope.test(request));
+    }
+}
+
+var index = (ctx, options = {}) => {
+    // 合并 harmony 编译配置到 opts
+    ctx.modifyRunnerOpts(({ opts }) => {
+        if (opts.platform !== PLATFORM_NAME)
+            return;
+        const harmonyConfig = ctx.ctx.initialConfig.harmony;
+        assertHarmonyConfig(ctx, harmonyConfig);
+        harmonyConfig.name || (harmonyConfig.name = 'default');
+        harmonyConfig.hapName || (harmonyConfig.hapName = 'entry');
+        const { projectPath, hapName } = harmonyConfig;
+        opts.outputRoot = path.join(projectPath, hapName, 'src/main', options.disableArkTS ? 'js' : 'ets');
+        opts.harmony = harmonyConfig;
+        ctx.paths.outputPath = opts.outputRoot;
+    });
+    const Harmony$2 = options.disableArkTS ? Harmony : Harmony$1;
+    ctx.registerPlatform({
+        name: PLATFORM_NAME,
+        useConfigName: options.useConfigName || PLATFORM_NAME,
+        fn({ config }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const program = new Harmony$2(ctx, config);
+                yield program.start();
+            });
+        }
+    });
+};
+function assertHarmonyConfig(ctx, config) {
+    const NOTE_INVALID = helper.chalk.red('[✗] ');
+    const errorChalk = helper.chalk.hex('#f00');
+    const lineChalk = helper.chalk.hex('#fff');
+    function throwError(err) {
+        console.log(errorChalk(`Taro 配置有误，请检查！ (${ctx.paths.configPath})`));
+        console.log(`  ${NOTE_INVALID}${lineChalk(err)}`);
+        process.exit(0);
+    }
+    if (typeof config !== 'object' || !config) {
+        throwError('请设置 harmony 编译配置');
+    }
+    if (!config.projectPath) {
+        throwError('请设置 harmony.projectPath');
+    }
+}
+
+exports.HarmonyOS_JSUI = Harmony;
+exports.default = index;
+//# sourceMappingURL=index.js.map