agora-toolchain 3.3.1 → 3.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agora-toolchain",
-  "version": "3.3.1",
+  "version": "3.4.0",
   "license": "MIT",
   "bin": {
     "agora-tc-transpile": "./scripts/transpile.js",

package/presets/karma.conf.js

@@ -1,12 +1,19 @@
 require('dotenv/config');
+const opts = require('../tools/karma-options');
 const webpackConfig = require('./webpack.karma')();
 const path = require('path');
 const cwd = process.cwd();
 
+const pattern = opts.file ?? '**/*.test.ts';
+
 const files =
   process.env.platform === 'browser'
-    ? ['__test__/universal/**/*.test.ts', '__test__/browser/**/*.test.ts']
-    : ['__test__/universal/**/*.test.ts', '__test__/electron/**/*.test.ts'];
+    ? pattern
+      ? [`__test__/${pattern}`]
+      : [`__test__/universal/**/*.test.ts`, `__test__/browser/**/*.test.ts`]
+    : pattern
+      ? [`__test__/${pattern}`]
+      : [`__test__/universal/**/*.test.ts`, `__test__/electron/**/*.test.ts`];
 
 const preprocessors =
   process.env.platform === 'browser'

package/presets/postcss-plugin/px-to-vw/index.js

@@ -0,0 +1,212 @@
+'use strict';
+var postcss = require('postcss');
+var objectAssign = require('object-assign');
+var { createPropListMatcher } = require('./src/prop-list-matcher');
+var { getUnitRegexp } = require('./src/pixel-unit-regexp');
+
+var defaults = {
+  unitToConvert: 'px',
+  viewportWidth: 320,
+  viewportHeight: 568, // not now used; TODO: need for different units and math for different properties
+  unitPrecision: 5,
+  viewportUnit: 'vw',
+  fontViewportUnit: 'vw', // vmin is more suitable.
+  selectorBlackList: [],
+  propList: ['*'],
+  minPixelValue: 1,
+  mediaQuery: false,
+  replace: true,
+  landscape: false,
+  landscapeUnit: 'vw',
+  landscapeWidth: 568,
+};
+
+var ignoreNextComment = 'px-to-viewport-ignore-next';
+var ignorePrevComment = 'px-to-viewport-ignore';
+
+module.exports = postcss.plugin('postcss-px-to-viewport', function (options) {
+  var opts = objectAssign({}, defaults, options);
+  checkRegExpOrArray(opts, 'exclude');
+  checkRegExpOrArray(opts, 'include');
+
+  var pxRegex = getUnitRegexp(opts.unitToConvert);
+  var satisfyPropList = createPropListMatcher(opts.propList);
+  var landscapeRules = [];
+
+  return function (css, result) {
+    css.walkRules(function (rule) {
+      // Add exclude option to ignore some files like 'node_modules'
+      var file = rule.source && rule.source.input.file;
+
+      if (opts.include && file) {
+        if (Object.prototype.toString.call(opts.include) === '[object RegExp]') {
+          if (!opts.include.test(file)) return;
+        } else if (Object.prototype.toString.call(opts.include) === '[object Array]') {
+          var flag = false;
+          for (var i = 0; i < opts.include.length; i++) {
+            if (opts.include[i].test(file)) {
+              flag = true;
+              break;
+            }
+          }
+          if (!flag) return;
+        }
+      }
+
+      if (opts.exclude && file) {
+        if (Object.prototype.toString.call(opts.exclude) === '[object RegExp]') {
+          if (opts.exclude.test(file)) return;
+        } else if (Object.prototype.toString.call(opts.exclude) === '[object Array]') {
+          for (var i = 0; i < opts.exclude.length; i++) {
+            if (opts.exclude[i].test(file)) return;
+          }
+        }
+      }
+
+      if (blacklistedSelector(opts.selectorBlackList, rule.selector)) return;
+
+      if (opts.landscape && !rule.parent.params) {
+        var landscapeRule = rule.clone().removeAll();
+
+        rule.walkDecls(function (decl) {
+          if (decl.value.indexOf(opts.unitToConvert) === -1) return;
+          if (!satisfyPropList(decl.prop)) return;
+
+          landscapeRule.append(
+            decl.clone({
+              value: decl.value.replace(
+                pxRegex,
+                createPxReplace(opts, opts.landscapeUnit, opts.landscapeWidth),
+              ),
+            }),
+          );
+        });
+
+        if (landscapeRule.nodes.length > 0) {
+          landscapeRules.push(landscapeRule);
+        }
+      }
+
+      if (!validateParams(rule.parent.params, opts.mediaQuery)) return;
+
+      rule.walkDecls(function (decl, i) {
+        if (decl.value.indexOf(opts.unitToConvert) === -1) return;
+        if (!satisfyPropList(decl.prop)) return;
+
+        var prev = decl.prev();
+        // prev declaration is ignore conversion comment at same line
+        if (prev && prev.type === 'comment' && prev.text === ignoreNextComment) {
+          // remove comment
+          prev.remove();
+          return;
+        }
+        var next = decl.next();
+        // next declaration is ignore conversion comment at same line
+        if (next && next.type === 'comment' && next.text === ignorePrevComment) {
+          if (/\n/.test(next.raws.before)) {
+            result.warn(
+              'Unexpected comment /* ' +
+                ignorePrevComment +
+                ' */ must be after declaration at same line.',
+              { node: next },
+            );
+          } else {
+            // remove comment
+            next.remove();
+            return;
+          }
+        }
+
+        var unit;
+        var size;
+        var params = rule.parent.params;
+
+        if (opts.landscape && params && params.indexOf('landscape') !== -1) {
+          unit = opts.landscapeUnit;
+          size = opts.landscapeWidth;
+        } else {
+          unit = getUnit(decl.prop, opts);
+          size = opts.viewportWidth;
+        }
+
+        var value = decl.value.replace(pxRegex, createPxReplace(opts, unit, size));
+
+        if (declarationExists(decl.parent, decl.prop, value)) return;
+
+        if (opts.replace) {
+          decl.value = value;
+        } else {
+          decl.parent.insertAfter(i, decl.clone({ value: value }));
+        }
+      });
+    });
+
+    if (landscapeRules.length > 0) {
+      var landscapeRoot = new postcss.AtRule({ params: '(orientation: landscape)', name: 'media' });
+
+      landscapeRules.forEach(function (rule) {
+        landscapeRoot.append(rule);
+      });
+      css.append(landscapeRoot);
+    }
+  };
+});
+
+function getUnit(prop, opts) {
+  return prop.indexOf('font') === -1 ? opts.viewportUnit : opts.fontViewportUnit;
+}
+
+function createPxReplace(opts, viewportUnit, viewportSize) {
+  return function (m, $1) {
+    if (!$1) return m;
+    var pixels = parseFloat($1);
+    if (pixels <= opts.minPixelValue) return m;
+    var parsedVal = toFixed((pixels / viewportSize) * 100, opts.unitPrecision);
+    return parsedVal === 0 ? '0' : parsedVal + viewportUnit;
+  };
+}
+
+function error(decl, message) {
+  throw decl.error(message, { plugin: 'postcss-px-to-viewport' });
+}
+
+function checkRegExpOrArray(options, optionName) {
+  var option = options[optionName];
+  if (!option) return;
+  if (Object.prototype.toString.call(option) === '[object RegExp]') return;
+  if (Object.prototype.toString.call(option) === '[object Array]') {
+    var bad = false;
+    for (var i = 0; i < option.length; i++) {
+      if (Object.prototype.toString.call(option[i]) !== '[object RegExp]') {
+        bad = true;
+        break;
+      }
+    }
+    if (!bad) return;
+  }
+  throw new Error('options.' + optionName + ' should be RegExp or Array of RegExp.');
+}
+
+function toFixed(number, precision) {
+  var multiplier = Math.pow(10, precision + 1),
+    wholeNumber = Math.floor(number * multiplier);
+  return (Math.round(wholeNumber / 10) * 10) / multiplier;
+}
+
+function blacklistedSelector(blacklist, selector) {
+  if (typeof selector !== 'string') return;
+  return blacklist.some(function (regex) {
+    if (typeof regex === 'string') return selector.indexOf(regex) !== -1;
+    return selector.match(regex);
+  });
+}
+
+function declarationExists(decls, prop, value) {
+  return decls.some(function (decl) {
+    return decl.prop === prop && decl.value === value;
+  });
+}
+
+function validateParams(params, mediaQuery) {
+  return !params || (params && mediaQuery);
+}

package/presets/postcss-plugin/px-to-vw/src/pixel-unit-regexp.js

@@ -0,0 +1,14 @@
+// excluding regex trick: http://www.rexegg.com/regex-best-trick.html
+
+// Not anything inside double quotes
+// Not anything inside single quotes
+// Not anything inside url()
+// Any digit followed by px
+// !singlequotes|!doublequotes|!url()|pixelunit
+function getUnitRegexp(unit) {
+  return new RegExp('"[^"]+"|\'[^\']+\'|url\\([^\\)]+\\)|(\\d*\\.?\\d+)' + unit, 'g');
+}
+
+module.exports = {
+  getUnitRegexp,
+};

package/presets/postcss-plugin/px-to-vw/src/prop-list-matcher.js

@@ -0,0 +1,118 @@
+var filterPropList = {
+  exact: function (list) {
+    return list.filter(function (m) {
+      return m.match(/^[^\*\!]+$/);
+    });
+  },
+  contain: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\*.+\*$/);
+      })
+      .map(function (m) {
+        return m.substr(1, m.length - 2);
+      });
+  },
+  endWith: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\*[^\*]+$/);
+      })
+      .map(function (m) {
+        return m.substr(1);
+      });
+  },
+  startWith: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^[^\*\!]+\*$/);
+      })
+      .map(function (m) {
+        return m.substr(0, m.length - 1);
+      });
+  },
+  notExact: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\![^\*].*$/);
+      })
+      .map(function (m) {
+        return m.substr(1);
+      });
+  },
+  notContain: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\!\*.+\*$/);
+      })
+      .map(function (m) {
+        return m.substr(2, m.length - 3);
+      });
+  },
+  notEndWith: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\!\*[^\*]+$/);
+      })
+      .map(function (m) {
+        return m.substr(2);
+      });
+  },
+  notStartWith: function (list) {
+    return list
+      .filter(function (m) {
+        return m.match(/^\![^\*]+\*$/);
+      })
+      .map(function (m) {
+        return m.substr(1, m.length - 2);
+      });
+  },
+};
+
+function createPropListMatcher(propList) {
+  var hasWild = propList.indexOf('*') > -1;
+  var matchAll = hasWild && propList.length === 1;
+  var lists = {
+    exact: filterPropList.exact(propList),
+    contain: filterPropList.contain(propList),
+    startWith: filterPropList.startWith(propList),
+    endWith: filterPropList.endWith(propList),
+    notExact: filterPropList.notExact(propList),
+    notContain: filterPropList.notContain(propList),
+    notStartWith: filterPropList.notStartWith(propList),
+    notEndWith: filterPropList.notEndWith(propList),
+  };
+  return function (prop) {
+    if (matchAll) return true;
+    return (
+      (hasWild ||
+        lists.exact.indexOf(prop) > -1 ||
+        lists.contain.some(function (m) {
+          return prop.indexOf(m) > -1;
+        }) ||
+        lists.startWith.some(function (m) {
+          return prop.indexOf(m) === 0;
+        }) ||
+        lists.endWith.some(function (m) {
+          return prop.indexOf(m) === prop.length - m.length;
+        })) &&
+      !(
+        lists.notExact.indexOf(prop) > -1 ||
+        lists.notContain.some(function (m) {
+          return prop.indexOf(m) > -1;
+        }) ||
+        lists.notStartWith.some(function (m) {
+          return prop.indexOf(m) === 0;
+        }) ||
+        lists.notEndWith.some(function (m) {
+          return prop.indexOf(m) === prop.length - m.length;
+        })
+      )
+    );
+  };
+}
+
+module.exports = {
+  filterPropList,
+  createPropListMatcher,
+};

package/presets/postcss.config.js

@@ -1,5 +1,18 @@
-const autoprefixer = require("autoprefixer");
-
+const autoprefixer = require('autoprefixer');
+const postcssPxToViewport = require('./postcss-plugin/px-to-vw/index');
 module.exports = {
-  plugins: [autoprefixer()],
+  plugins: [
+    autoprefixer(),
+    postcssPxToViewport({
+      viewportWidth: 375,
+      unitPrecision: 5,
+      viewportUnit: 'vw',
+      fontViewportUnit: 'vw',
+      exclude: [/\/node_modules\//i],
+      landscape: true, // 是否处理横屏情况
+      landscapeUnit: 'vw', // (String) 横屏时使用的单位
+      landscapeWidth: 812, // (Number) 横屏时使用的视口宽度
+      landscapeHeight: 375, // (Number) 横屏时使用的视口宽度
+    }),
+  ],
 };

package/presets/webpack.base.js

@@ -34,8 +34,9 @@ module.exports = {
         'agora-foundation',
         'agora-ui-foundation',
         'agora-rte-sdk',
-        'agora-edu-core',
+        'fcr-core',
         'fcr-ui-scene',
+        'fcr-ui-scene-mobile',
       ]),
     },
     extensions: ['.ts', '.js', '.tsx'],

package/presets/webpack.dev.js

@@ -8,7 +8,6 @@ const { getCodeOfDeclaredVariables } = require('../tools/ast-utils');
 const baseConfig = require('./webpack.base');
 const { resolveCwd, resolveModule } = require('../tools/paths');
 const fs = require('fs');
-
 module.exports = createConfig = ({ entry, port = 3000, analyze }) => {
   const extractArray = (str = '') => {
     if (!str) {

package/scripts/bundle.js

@@ -8,8 +8,15 @@ const webpackConfig = require(webpackProdPath)({ entry, analyze, out });
 
 Webpack(webpackConfig, (err, stats) => {
   // TODO: write error stack and stats to local disk, dont print log to the console
+
   if (err || stats.hasErrors()) {
-    console.error('Stats', stats);
-    console.error('Build failed', err);
+    console.error(`Build failed`);
+    if (err) {
+      console.error(`cause: ${err.cause}`);
+      console.error(`message: ${err.message}`);
+      console.error(`stack: ${err.stack}`);
+    }
+    console.error(`stats: ${stats.toString()}`);
+    process.exit(1);
   }
 });

package/scripts/pack-client-app.js

@@ -78,7 +78,9 @@ const options = {
           to: 'assets/pretest.mp3',
         },
       ],
-  files: cpp ? ['!**/node_modules/agora-electron-sdk/**/*'] : ['**/*'],
+  files: cpp
+    ? ['!**/node_modules/agora-electron-sdk/**/*', '!**/artifactory_deps/**/*']
+    : ['**/*', '!**/artifactory_deps/**/*'],
   // files: [
   //   // 'node_modules//**/*',
   //   {
@@ -114,6 +116,11 @@ const options = {
       NSMicrophoneUsageDescription: 'Fcr Meeting wants to acquire your microphone permission',
       NSCameraUsageDescription: 'Fcr Meeting wants to acquire your camera permission',
       NSScreenCaptureDescription: 'Fcr Meeting wants to acquire your screen capture permission',
+      'com.apple.security.device.audio-input': true,
+      'com.apple.security.cs.allow-jit': true,
+      'com.apple.security.cs.allow-unsigned-executable-memory': true,
+      'com.apple.security.cs.allow-dyld-environment-variables': true,
+      'com.apple.security.device.camera': true,
     },
   },
   dmg: {

package/scripts/pack-client-sdk.js

@@ -32,8 +32,10 @@ function copyDirSync(source, target) {
     }
   }
 }
-
-// copyDirSync(resolveBase('lib'), resolveCwd('dist'));
+if (!fs.existsSync(resolveCwd('dist/assets'))) {
+  fs.mkdirSync(resolveCwd('dist/assets'));
+}
+fs.copyFileSync(resolveCwd('public/assets/loading.gif'), resolveCwd('dist/assets/loading.gif'));
 
 // Let's get that intellisense working
 /**
@@ -82,6 +84,7 @@ const options = {
     output: resolveCwd('release'),
     buildResources: resolveCwd('installer/resources'),
   },
+  files: ['!**/artifactory_deps/**/*'],
   // files: [
   //   // 'node_modules//**/*',
   //   {
@@ -94,6 +97,10 @@ const options = {
       from: resolveCwd('public/assets/pretest.mp3'),
       to: 'assets/pretest.mp3',
     },
+    {
+      from: resolveCwd('public/assets/loading.gif'),
+      to: 'assets/loading.gif',
+    },
   ],
   // extraFiles: [
   //   {

package/scripts/test-karma-browser.js

@@ -7,7 +7,7 @@ const karmaPresetPath = path.join(presetsDir, 'karma.conf.js');
 
 process.env.platform = 'browser';
 
-spawn(require.resolve('.bin/karma'), ['start', karmaPresetPath], {
+spawn(require.resolve('.bin/karma'), ['start', karmaPresetPath, ...process.argv], {
   stdio: 'inherit',
 }).on('exit', (code) => {
   if (code === 0) {

package/scripts/test-karma-electron.js

@@ -41,7 +41,7 @@ waitOn(
   },
 );
 
-spawn(require.resolve('.bin/karma'), ['start', karmaPresetPath], {
+spawn(require.resolve('.bin/karma'), ['start', karmaPresetPath, ...process.argv], {
   stdio: 'inherit',
 }).on('exit', (code) => {
   if (code === 0) {

package/tools/karma-options.js

@@ -0,0 +1,8 @@
+const { program } = require('commander');
+
+const opts = program
+  .option('--file <file>', 'Specify an UT to run')
+  .parse(process.argv)
+  .opts();
+
+module.exports = opts;

package/tools/webpack-utils.js

@@ -3,19 +3,24 @@ const { resolveModule } = require('./paths');
 
 const sourceAlias = (libs) => {
   return libs.reduce((prev, libName) => {
-    const modulePath = resolveModule(libName);
+    try {
+      const modulePath = resolveModule(libName);
 
-    const srcPath = `${modulePath}/src`;
+      const srcPath = `${modulePath}/src`;
 
-    if (existsSync(srcPath)) {
-      console.log(`source linker: ${libName} linked`);
+      if (existsSync(srcPath)) {
+        console.log(`source linker: ${libName} linked`);
 
-      prev[`${libName}/lib`] = srcPath;
+        prev[`${libName}/lib`] = srcPath;
 
-      prev[`${libName}`] = srcPath;
-    }
+        prev[`${libName}`] = srcPath;
+      }
 
-    return prev;
+      return prev;
+    } catch (e) {
+      console.log(`source linker: ${libName} not found`);
+      return prev;
+    }
   }, {});
 };