hw-weapp-compiler 1.0.0

package/build/prod.js

@@ -0,0 +1,34 @@
+const chalk = require('chalk');
+const webpack = require('webpack');
+const ENV = require('./config/env');
+const webpackConfig = require('./webpack.config');
+
+module.exports = (opts) => {
+  const compiler = webpack(
+    webpackConfig(
+      {
+        mode: ENV.PROD,
+        devtool: 'cheap-module-source-map',
+      },
+      opts || {},
+    ),
+  );
+
+  compiler.run((err, stats) => {
+    if (err) {
+      console.error(err);
+      return;
+    }
+
+    if (stats.hasErrors()) {
+      console.log(
+        stats.toString({
+          chunks: false, // Makes the build much quieter
+          colors: true, // Shows colors in the console
+        }),
+      );
+    }
+
+    console.log(chalk.green(`completed in ${(stats.endTime - stats.startTime) / 1000} seconds`));
+  });
+};

package/build/utils/buildEnv.js

@@ -0,0 +1,31 @@
+const ENV = require('../config/env');
+const recordEnv = require('./recordEnv');
+
+let env = '';
+
+function setBuildEnv({ mode, development, simulation, production }) {
+  env = mode;
+
+  if (development) {
+    env = ENV.DEV;
+  }
+  if (simulation) {
+    env = ENV.SIMULATION;
+  }
+  if (production) {
+    env = ENV.PROD;
+  }
+
+  recordEnv({
+    env,
+  });
+}
+
+function getBuildEnv() {
+  return env;
+}
+
+module.exports = {
+  setBuildEnv,
+  getBuildEnv,
+};

package/build/utils/compatiblePath.js

@@ -0,0 +1,13 @@
+const os = require('os');
+
+const platform = os.platform();
+
+function compatiblePath(str) {
+  if (platform === 'win32') {
+    // path.win32.normalize()
+    return str.replace(/\\/g, '/');
+  }
+  return str;
+}
+
+module.exports = compatiblePath;

package/build/utils/getWxmlAssets.js

@@ -0,0 +1,107 @@
+const htmlparser2 = require('htmlparser2');
+const path = require('path');
+const fse = require('fs-extra');
+const getResourceAccept = require('../config/getResourceAccept');
+const getContext = require('../config/getContext');
+
+const context = getContext();
+
+function getWxmlAssets(filePath, content) {
+  const resolvePath = (attr, dir) => {
+    // console.log('-------------');
+    // console.log(attr, dir);
+    // console.log('-------------');
+    return new Promise((resolve) => {
+      this.resolve(context, attr, async (err, result) => {
+        let res = result;
+        if (err) {
+          if (await fse.pathExists(path.resolve(dir, attr))) {
+            res = path.resolve(dir, attr);
+            resolve(res);
+          } else {
+            // console.log('-------------');
+            // console.log(attr);
+            this.emitError(err);
+            // this.emitWarning(err);
+            // reject(err);
+            resolve(res);
+          }
+        } else {
+          resolve(res);
+        }
+      });
+    });
+  };
+  return new Promise((resolve, reject) => {
+    let allAttrs = [];
+    const parser = new htmlparser2.Parser({
+      onopentag: async (name, attributes) => {
+        const reg = /url\(.*\)/g;
+        const { style } = attributes;
+
+        allAttrs = allAttrs.concat(
+          Object.values({
+            ...attributes,
+            style: '',
+          }),
+        );
+
+        if (style) {
+          const styles = attributes.style.split(';');
+          styles.forEach((styleItem) => {
+            (styleItem.match(reg) || []).forEach((item) => {
+              allAttrs.push(
+                item
+                  .replace(/^(url\(”)/g, '')
+                  .replace(/^(url\(')/g, '')
+                  .replace(/^(url\()/g, '')
+                  .replace(/(“\)|'\)|\))$/g, ''),
+              );
+            });
+          });
+        }
+      },
+      onerror: (err) => {
+        reject(err);
+      },
+      onend: async () => {
+        const filteredAttrs = allAttrs
+          .filter((item) => !!item)
+          .map((item) => item.split('?')[0])
+          .filter((item) => !/^(http:|https:)/.test(item))
+          .filter((item) => !/{{.*}}/g.test(item))
+          .filter((item) => !/\+.*\+/g.test(item));
+
+        const assets = filteredAttrs.filter((item) => getResourceAccept().test(item));
+        const wxmls = allAttrs.filter((item) => /\.(wxs|wxml)$/g.test(item));
+
+        const assetsImports = [];
+        const wxmlsImports = [];
+
+        for (let index = 0; index < wxmls.length; index += 1) {
+          const attr = wxmls[index];
+          const result = await resolvePath(attr, path.parse(filePath).dir);
+
+          if (result) {
+            wxmlsImports.push([attr, result]);
+          }
+        }
+
+        for (let index = 0; index < assets.length; index += 1) {
+          const attr = assets[index];
+          const result = await resolvePath(attr, path.parse(filePath).dir);
+
+          if (result) {
+            assetsImports.push([attr, result]);
+          }
+        }
+
+        resolve([assetsImports, wxmlsImports]);
+      },
+    });
+    parser.write(content);
+    parser.end();
+  });
+}
+
+module.exports = getWxmlAssets;

package/build/utils/isNodeModulesUsingComponent.js

@@ -0,0 +1,17 @@
+const nodeModulesUsingComponent = [];
+
+function isNodeModulesUsingComponent(name) {
+  const key = name.replace(/\.(js|wxml|wxss|json|wxs)$/g, '');
+  const nmIndex = key.indexOf('node_modules/');
+  const searchKey = nmIndex !== -1 ? key.substring(nmIndex + 'node_modules/'.length) : key;
+  return nodeModulesUsingComponent.indexOf(searchKey) !== -1;
+}
+
+function addNodeModulesUsingComponent(item) {
+  nodeModulesUsingComponent.push(item);
+}
+
+module.exports = {
+  isNodeModulesUsingComponent,
+  addNodeModulesUsingComponent,
+};

package/build/utils/isSubpackage.js

@@ -0,0 +1,22 @@
+const compatiblePath = require('./compatiblePath');
+const getAppConfig = require('../config/getAppConfig');
+
+const appConfig = getAppConfig();
+
+function isSubpackage(file) {
+  let isSub = false;
+
+  (appConfig.subpackages || []).forEach((pkg) => {
+    let { root } = pkg;
+
+    if (!/\/$/g.test(root)) {
+      root = `${root}/`;
+    }
+
+    if (compatiblePath(file).indexOf(root) === 0) {
+      isSub = true;
+    }
+  });
+  return isSub;
+}
+module.exports = isSubpackage;

package/build/utils/loadModule.js

@@ -0,0 +1,19 @@
+function loadModule(file) {
+  return new Promise((resolve) => {
+    this.addDependency(file);
+    this.loadModule(file, (err, src) => {
+      if (err) {
+        // console.log();
+        // console.log(file, this.resourcePath);
+        // console.log();
+        this.emitError(err);
+        // this.emitWarning(err);
+        // reject(err);
+        resolve(src);
+      } else {
+        resolve(src);
+      }
+    });
+  });
+}
+module.exports = loadModule;

package/build/utils/recordEnv.js

@@ -0,0 +1,11 @@
+const fs = require('fs-extra');
+const path = require('path');
+const getOutput = require('../config/getOutput');
+const ENV = require('../config/env');
+
+module.exports = (config) => {
+  fs.writeJSONSync(path.join(getOutput(), 'weapp.env.json'), {
+    env: ENV.DEV,
+    ...config,
+  });
+};

package/build/utils/storage.js

@@ -0,0 +1,29 @@
+const path = require('path');
+const fs = require('fs-extra');
+const { debounce } = require('throttle-debounce');
+
+const tempDir = path.resolve(process.cwd(), '.temp');
+const uploadJsonDir = path.join(tempDir, 'upload.json');
+let uploadJson = {};
+const writeUploadJsonDebounce = debounce(300, () => {
+  fs.writeJSONSync(uploadJsonDir, uploadJson);
+});
+
+if (!fs.existsSync(tempDir)) {
+  fs.mkdirSync(tempDir);
+}
+if (!fs.existsSync(uploadJsonDir)) {
+  fs.writeJSONSync(uploadJsonDir, uploadJson);
+} else {
+  uploadJson = fs.readJSONSync(uploadJsonDir);
+}
+
+module.exports = {
+  getStorage(key) {
+    return uploadJson[key];
+  },
+  setStorage(key, value) {
+    uploadJson[key] = value;
+    writeUploadJsonDebounce();
+  },
+};

package/build/utils/traverseDir.js

@@ -0,0 +1,21 @@
+const fs = require('fs');
+const path = require('path');
+
+function traverseDir(dir) {
+  let result = [];
+  const files = fs.readdirSync(dir);
+
+  files.forEach((file) => {
+    const fullPath = path.resolve(dir, file);
+
+    if (fs.statSync(fullPath).isDirectory()) {
+      result = result.concat(traverseDir(fullPath));
+    } else {
+      result.push(fullPath);
+    }
+  });
+
+  return result;
+}
+
+module.exports = traverseDir;

package/build/utils/upload.js

@@ -0,0 +1,194 @@
+const path = require('path');
+const OBSClient = require('esdk-obs-nodejs');
+const OSSClient = require('ali-oss');
+// const chalk = require('chalk');
+const Progress = require('progress');
+const getConfig = require('../config/getConfig');
+
+const { getStorage, setStorage } = require('./storage');
+const compatiblePath = require('./compatiblePath');
+const getOutput = require('../config/getOutput');
+
+const output = getOutput();
+const { obsConfig, ossConfig } = getConfig();
+
+let obsClient;
+let ossClient;
+let progress;
+let uploadQueue = {};
+
+function getObsClient() {
+  if (!obsClient) {
+    obsClient = new OBSClient({
+      ...obsConfig,
+    });
+  }
+  return obsClient;
+}
+
+function getOssClient() {
+  if (!ossClient) {
+    ossClient = new OSSClient({
+      ...ossConfig,
+    });
+  }
+  return ossClient;
+}
+
+function doOssUpload(file) {
+  return getOssClient().put(
+    compatiblePath(path.join(ossConfig.dir, path.relative(output, file))),
+    file,
+  );
+}
+
+function getOssStat(file) {
+  return getOssClient().head(compatiblePath(path.join(ossConfig.dir, path.relative(output, file))));
+}
+
+function doObsUpload(file) {
+  return new Promise((resolve, reject) => {
+    getObsClient().putObject(
+      {
+        Bucket: obsConfig.bucket,
+        Key: compatiblePath(path.join(obsConfig.dir, path.relative(output, file))),
+        SourceFile: file,
+      },
+      (err, result) => {
+        if (err) {
+          reject(err);
+          // console.log(chalk.red("上传失败"), file);
+        } else if (result.CommonMsg.Status >= 300) {
+          reject(new Error(`OBS upload failed with status ${result.CommonMsg.Status}`));
+          // console.log(chalk.red("上传失败"), file);
+        } else {
+          resolve(result);
+          // console.log(chalk.green("上传成功"), file);
+        }
+      },
+    );
+  });
+}
+async function getObsStat(file) {
+  return new Promise((resolve, reject) => {
+    getObsClient().getObjectMetadata(
+      {
+        Bucket: obsConfig.bucket,
+        Key: compatiblePath(path.join(obsConfig.dir, path.relative(output, file))),
+      },
+      (err, result) => {
+        if (err) {
+          reject(err);
+        } else if (result.CommonMsg.Status < 300) {
+          resolve(result);
+        } else {
+          reject(result);
+        }
+      },
+    );
+  });
+}
+
+function getStat(file) {
+  const isUploaded = !!getStorage(file);
+
+  if (isUploaded) {
+    return Promise.resolve();
+  }
+
+  if (ossConfig) {
+    return getOssStat(file);
+  }
+  return getObsStat(file);
+}
+
+function doUpload(file) {
+  if (ossConfig) {
+    return doOssUpload(file);
+  }
+  return doObsUpload(file);
+}
+
+function updateProgress() {
+  const completed =
+    Object.entries(uploadQueue).filter((item) => item[1] === 'completed').length + 1;
+  const total = Object.keys(uploadQueue).length;
+
+  if (!progress) {
+    progress = new Progress('uploading assets [:bar] :current/:total', {
+      total,
+      width: 40,
+      clear: true,
+    });
+  }
+
+  progress.tick();
+
+  if (completed === total) {
+    progress.tick({
+      current: total,
+    });
+    progress = null;
+    uploadQueue = {};
+    // setTimeout(() => {
+    //   console.log(chalk.green('assets upload completed'));
+    // }, 0);
+  }
+
+  return `[${completed}/${total}]`;
+}
+
+async function checkUpload() {
+  const files = Object.entries(uploadQueue)
+    .filter((item) => item[1] === false)
+    .splice(0, 10);
+
+  if (files && files.length) {
+    await Promise.all(
+      files.map(async (file) => {
+        uploadQueue[file[0]] = 'uploading';
+        try {
+          await getStat(file[0]);
+          setStorage(file[0], true);
+          updateProgress();
+          // console.log(
+          //   chalk.blue(`${publicPath}${path.relative(output, file[0])} ${updateProgress()}`),
+          // );
+        } catch (error) {
+          try {
+            await doUpload(file[0]);
+            setStorage(file[0], true);
+          } catch (uploadError) {
+            console.error(`Failed to upload ${file[0]}:`, uploadError);
+          }
+          updateProgress();
+          // console.log(
+          //   chalk.green(`${publicPath}${path.relative(output, file[0])} ${updateProgress()}`),
+          // );
+        }
+        uploadQueue[file[0]] = 'completed';
+      }),
+    );
+
+    checkUpload();
+  }
+}
+
+function addToUploadQueue(assets) {
+  if (!obsConfig && !ossConfig) {
+    console.warn('请配置obsConfig 或 ossConfig，否则无法上传文件到obs 或 oss');
+    return;
+  }
+
+  assets.forEach((asset) => {
+    const file = path.resolve(output, asset);
+    if (uploadQueue[file] === undefined) {
+      uploadQueue[file] = false;
+    }
+  });
+  checkUpload();
+}
+
+module.exports = {
+  addToUploadQueue,
+};