hof 22.8.4-unhandled-error-fix-beta.1 → 22.9.0-beta

package/package/bin/hof-build

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+'use strict';
+
+/* eslint-disable no-process-exit */
+const options = require('minimist')(process.argv.slice(2));
+require('../build/')(options)
+  .catch(e => {
+    console.error(e.stack);
+    process.exit(1);
+  });

package/package/bin/hof-transpiler

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+'use strict';
+
+const args = require('minimist')(process.argv.slice(2));
+const compile = require('../transpiler/lib/compile');
+
+const options = {};
+
+options.sources = args._;
+options.shared = args.shared || args.s || [];
+
+compile(options);

package/package/build/helpers/importer.js

@@ -0,0 +1,29 @@
+const local = require('./local');
+const resolve = require('./resolver');
+
+module.exports = function (options) {
+  const importerOptions = options || {};
+
+  function importer(url, file, done) {
+    let importerUrl = url;
+    if (importerOptions.aliases && importerOptions.aliases[importerUrl]) {
+      importerUrl = importerOptions.aliases[importerUrl];
+    }
+
+    local(importerUrl, file, function (err, isLocal) {
+      if (err || isLocal) {
+        done({ file: importerUrl });
+      } else {
+        resolve(importerUrl, file)
+          .catch(function () { return importerUrl; })
+          .then(function (path) {
+            const importerPath = path.replace(/\.css$/, '');
+            return { file: importerPath };
+          })
+          .then(done);
+      }
+    });
+  }
+
+  return importer;
+};

package/package/build/helpers/local.js

@@ -0,0 +1,35 @@
+const path = require('path');
+const glob = require('glob');
+
+module.exports = function (url, file, done) {
+  // if url starts with . or / then assume it's a local/relative path
+  if (['.', path.sep].indexOf(url.substr(0, 1)) > -1) {
+    return done(null, true);
+  }
+
+  // otherwise construct a glob to match possible relative file paths
+  const basedir = path.dirname(file);
+
+  const bits = url.split(path.sep);
+
+  let filename = bits.pop();
+  const filepath = bits.join(path.sep);
+
+  // support _ prefixing of filenames
+  if (filename[0] !== '_') {
+    filename = '?(_)' + filename;
+  }
+
+  // match .scss, .sass or .css if the extension is not defined
+  if (filename.indexOf('.') === -1) {
+    filename += '.@(sa|c|sc)ss';
+  }
+
+  const target = path.join(basedir, filepath, filename);
+
+  // test the constructed glob against the file system for possible matches
+  glob(target, function (err, list) {
+    done(err, list.length);
+  });
+  return null;
+};

package/package/build/helpers/resolver/import.js

@@ -0,0 +1,32 @@
+const path = require('path');
+
+function Import(importUrl) {
+  this.importUrl = importUrl;
+}
+
+Import.prototype.isScoped = function () {
+  return this.importUrl[0] === '@';
+};
+
+Import.prototype.packageName = function () {
+  if (this.isScoped()) {
+    return this.importUrl.split(path.sep, 2).join(path.sep);
+  }
+  return this.importUrl.split(path.sep, 1)[0];
+};
+
+Import.prototype.isEntrypoint = function () {
+  const safePathSplitPattern = new RegExp(path.sep + '.');
+  const pathSegmentCount = this.importUrl.split(safePathSplitPattern).length;
+
+  if (this.isScoped()) {
+    return pathSegmentCount === 2;
+  }
+  return pathSegmentCount === 1;
+};
+
+Import.prototype.specifiedFilePath = function () {
+  return this.importUrl.slice(this.packageName().length);
+};
+
+module.exports = Import;

package/package/build/helpers/resolver/nearest-package-root.js

@@ -0,0 +1,33 @@
+/* eslint-disable no-console */
+const path = require('path');
+const findup = require('findup');
+
+/**
+ * @param {string} importOriginPath Path of file that made @import reference
+ */
+module.exports = function (packageName, importOriginPath) {
+  const pathToFind = path.join('node_modules', packageName, 'package.json');
+  const dirnameOfImportOrigin = path.dirname(importOriginPath);
+  let handleFoundPath;
+
+  const promise = new Promise(function (resolve, reject) {
+    handleFoundPath = function (err, nearestPackageParent) {
+      if (err) {
+        try {
+          return resolve(path.dirname(require.resolve(`${packageName}/package.json`)));
+        } catch (e) {
+          console.log(e);
+        }
+        return reject(err);
+      }
+
+      const packageJSONLocation = path.join(nearestPackageParent, 'node_modules', packageName);
+
+      return resolve(packageJSONLocation);
+    };
+  });
+
+  findup(dirnameOfImportOrigin, pathToFind, handleFoundPath);
+
+  return promise;
+};

package/package/build/helpers/resolver/package.js

@@ -0,0 +1,29 @@
+const path = require('path');
+
+function Package(rootPath) {
+  this.root = path.join.bind(null, rootPath);
+  this.JSON = require(this.root('package.json'));
+}
+
+Package.prototype.fullPathToEntrypoint = function () {
+  return this.root(this.entrypoint());
+};
+
+Package.prototype.entrypoint = function () {
+  if (this.JSON.sass) {
+    return this.JSON.sass;
+    // look for "style" declaration in package.json
+  } else if (this.JSON.style) {
+    return this.JSON.style;
+    // look for "styles" declaration in package.json
+  } else if (this.JSON.styles) {
+    return this.JSON.styles;
+    // look for a css/sass/scss file in the "main" declaration in package.json
+  } else if (/\.(sa|c|sc)ss$/.test(this.JSON.main)) {
+    return this.JSON.main;
+    // otherwise assume ./styles.scss
+  }
+  return 'styles';
+};
+
+module.exports = Package;

package/package/build/helpers/resolver.js

@@ -0,0 +1,16 @@
+const Package = require('./resolver/package');
+const Import = require('./resolver/import');
+const nearestPackageRoot = require('./resolver/nearest-package-root');
+
+module.exports = function (importUrl, importOriginPath) {
+  const _import = new Import(importUrl);
+
+  return nearestPackageRoot(_import.packageName(), importOriginPath).then(function (packageRoot) {
+    const _package = new Package(packageRoot);
+
+    if (_import.isEntrypoint()) {
+      return _package.fullPathToEntrypoint();
+    }
+    return _package.root(_import.specifiedFilePath());
+  });
+};

package/package/build/index.js

@@ -0,0 +1,49 @@
+/* eslint-disable no-console */
+'use strict';
+
+const path = require('path');
+const merge = require('lodash').merge;
+const config = require('../config/builder-defaults');
+
+module.exports = options => {
+  const settings = {};
+
+  merge(settings, config);
+
+  // load settings from ./hof.settings.json if it exists
+  let localConfig;
+  let hofSettings;
+  try {
+    localConfig = path.resolve(process.cwd(), './hof.settings');
+    hofSettings = require(localConfig).build || {};
+    hofSettings.theme = require(localConfig).theme;
+  } catch (e) {
+    // ignore error for missing config file
+  }
+
+  if (hofSettings) {
+    console.log(`Found local config at ${localConfig}`);
+    merge(settings, hofSettings);
+  }
+
+  // load override config file if defined
+  if (options.config) {
+    merge(settings, require(path.resolve(process.cwd(), options.config)));
+  }
+
+  settings.production = options.production || process.env.NODE_ENV === 'production';
+  settings.watchNodeModules = options['watch-node-modules'];
+  settings.watchDotFiles = options['watch-dotfiles'];
+  settings.verbose = options.verbose;
+  settings.env = options.env;
+
+  const task = options._[0] || 'build';
+
+  try {
+    require.resolve(`./tasks/${task}`);
+  } catch (e) {
+    throw new Error(`Unknown task: ${task}`);
+  }
+
+  return require(`./tasks/${task}`)(settings);
+};

package/package/build/lib/env.js

@@ -0,0 +1,36 @@
+/* eslint-disable no-console */
+'use strict';
+
+const fs = require('fs');
+const dotenv = require('dotenv');
+
+function hasenv(envfile) {
+  return new Promise(resolve => {
+    fs.stat(envfile, (err, stat) => err ? resolve(false) : resolve(stat.isFile()));
+  });
+}
+
+function readenv(envfile) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(envfile, (err, data) => err ? reject(err) : resolve(data));
+  });
+}
+
+function loadenv(envfile, enabled) {
+  return hasenv(envfile)
+    .then(exists => {
+      if (!exists && enabled) {
+        throw new Error(`No env file could be found at ${envfile}`);
+      } else if (exists && !enabled) {
+        console.log(`Local env file found at ${envfile}.`);
+        console.log('To load variables from this file run with --env.');
+      } else if (exists && enabled) {
+        console.log(`Loading variables from env file at ${envfile}`);
+        return readenv(envfile)
+          .then(env => dotenv.parse(env));
+      }
+      return {};
+    });
+}
+
+module.exports = loadenv;

package/package/build/lib/mkdir.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+module.exports = file => new Promise((resolve, reject) => {
+  const dir = path.dirname(file);
+  fs.mkdir(dir, {recursive: true}, err => err ? reject(err) : resolve());
+});

package/package/build/lib/run.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+'use strict';
+
+module.exports = (tasks, config) => tasks.reduce((promise, task) => {
+  const name = task.task || 'unknown';
+  return promise
+    .then(() => {
+      console.log(`Executing task: ${name}`);
+      return task(config);
+    })
+    .then(() => {
+      console.log(`Completed task: ${name}`);
+    });
+}, Promise.resolve())
+  .then(() => {
+    console.log();
+  });

package/package/build/lib/spawn.js

@@ -0,0 +1,18 @@
+/* eslint-disable no-param-reassign */
+'use strict';
+
+const cp = require('child_process');
+
+module.exports = (cmd, args) => new Promise((resolve, reject) => {
+  if (process.env.HOF_SANDBOX === 'true') {
+    cmd = cmd.replace('node_modules/hof', '..');
+  }
+
+  const child = cp.spawn(cmd, args, {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    shell: true
+  });
+  child.on('error', reject);
+  child.on('exit', code => code === 0 ? resolve() : reject(new Error(`${cmd} exited with a non-zero code: ${code}`)));
+});

package/package/build/tasks/browserify/compress.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const duplexify = require('duplexify');
+const spawn = require('child_process').spawn;
+const which = require('../../../lib/which');
+const bin = which('uglify-js', 'uglifyjs');
+
+const args = ['--comments', '/copyright|licen(c|s)e/i', '--'];
+
+function uglify() {
+  const proc = spawn(bin, args, { stdio: 'pipe' });
+  return duplexify(proc.stdin, proc.stdout);
+}
+
+module.exports = uglify;

package/package/build/tasks/browserify/index.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const browserify = require('browserify');
+const fs = require('fs');
+const path = require('path');
+const minify = require('./compress');
+const exorcist = require('exorcist');
+
+const mkdir = require('../../lib/mkdir');
+
+module.exports = config => {
+  if (!config.browserify) {
+    return Promise.resolve();
+  }
+
+  const out = path.resolve(process.cwd(), config.browserify.out);
+
+  // Enable debug mode (builds source maps) only if not in production
+  const debugMode = !config.production && config.browserify.debug;
+
+  return mkdir(out)
+    .then(() => new Promise((resolve, reject) => {
+      const bundler = browserify(config.browserify.src, {debug: debugMode});
+      if (config.theme) {
+        bundler.transform(require('aliasify'), {
+          aliases: {
+            $$theme: `hof-theme-${config.theme}`
+          }
+        });
+      }
+      let stream = bundler.bundle();
+      if (config.browserify.compress || config.production) {
+        stream = stream.pipe(minify());
+      }
+
+      // If debugging, use exorcist to extract a source map
+      if (debugMode) {
+        const mapPath = path.join(path.dirname(out), path.basename(out) + '.map');
+        stream = stream.pipe(exorcist(mapPath));
+      }
+
+      stream = stream.pipe(fs.createWriteStream(out));
+
+      stream.on('finish', resolve).on('error', reject);
+    }));
+};
+
+module.exports.task = 'browserify';

package/package/build/tasks/build/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const tasks = require('../');
+const run = require('../../lib/run');
+
+module.exports = config => run(Object.keys(tasks).map(task => tasks[task]), config);

package/package/build/tasks/images/index.js

@@ -0,0 +1,27 @@
+/* eslint-disable no-console */
+'use strict';
+
+const fs = require('fs');
+const chalk = require('chalk');
+const spawn = require('../../lib/spawn');
+const mkdir = require('../../lib/mkdir');
+
+module.exports = config => {
+  if (!config.images) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    fs.stat(config.images.src, err => err ? reject(err) : resolve());
+  })
+    .then(() => mkdir(config.images.out))
+    .then(() => spawn('cp', ['-r', config.images.src, config.images.out]))
+    .catch(e => {
+      if (e.code !== 'ENOENT') {
+        throw e;
+      } else {
+        console.log(`${chalk.yellow('warning')}: no images directory found at ${config.images.src}`);
+      }
+    });
+};
+module.exports.task = 'copy images';

package/package/build/tasks/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = {
+  browserify: require('./browserify'),
+  sass: require('./sass'),
+  translate: require('./translate'),
+  images: require('./images')
+};

package/package/build/tasks/sass/index.js

@@ -0,0 +1,67 @@
+/* eslint-disable no-console */
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const sass = require('sass');
+const importer = require('../../helpers/importer');
+const mkdir = require('../../lib/mkdir');
+const hofConfig = require('../../../config/hof-defaults');
+const logger = require('../../../lib/logger')(hofConfig);
+
+module.exports = config => {
+  if (!config.sass) {
+    return Promise.resolve();
+  }
+
+  const out = path.resolve(process.cwd(), config.sass.out);
+
+  return mkdir(out)
+    .then(() => new Promise((resolve, reject) => {
+      const aliases = {};
+
+      if (config.theme) {
+        console.log('Applying theme: ' + config.theme);
+        aliases.$$theme = `hof-theme-${config.theme}`;
+      }
+
+      // Build source maps if we are not in production
+      const createSourceMaps = !config.production && config.sass.sourceMaps;
+
+      sass.render({
+        file: config.sass.src,
+        importer: importer({ aliases }),
+        aliases,
+        outputStyle: config.sass.outputStyle,
+        quietDeps: config.sass.quietDeps,
+        outFile: out,
+        sourceMap: createSourceMaps
+      }, (err, result) => err ? reject(err) : resolve(result));
+    }))
+    .then(result => {
+      // Write the compiled CSS to the output file
+      const writeCss = new Promise((resolve, reject) => {
+        fs.writeFile(out, result.css, err => err ? reject(err) : resolve());
+      });
+
+      // If a sourcemap was generated, write it to a separate file
+      if (result.map) {
+        const mapPath = path.join(path.dirname(out), path.basename(out) + '.map');
+        const writeMap = new Promise((resolve, reject) => {
+          fs.writeFile(mapPath, result.map, err => {
+            if (err) {
+              logger.error('Failed to create sourcemap:', err);
+              reject(err);
+            } else {
+              logger.info('Sourcemap created successfully:', mapPath);
+              resolve();
+            }
+          });
+        });
+        return Promise.all([writeCss, writeMap]);
+      }
+
+      return writeCss;
+    });
+};
+module.exports.task = 'compile sass';

package/package/build/tasks/translate/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const spawn = require('../../lib/spawn');
+
+module.exports = config => {
+  if (!config.translate) {
+    return Promise.resolve();
+  }
+
+  const args = [config.translate.src];
+  if (config.translate.shared) {
+    const shared = [].concat(config.translate.shared);
+    shared.forEach(path => {
+      args.push('--shared', path);
+    });
+  }
+
+  return spawn('node_modules/hof/bin/hof-transpiler', args);
+};
+module.exports.task = 'compile translations';