[changed] constructor signatures of Compiler, JSCompiler, SASSCompiler, JS and SASS to allow for additional options to be passed more easily; JSCompiler now supports the "library" and "libraryTarget" options from webpack

Author: thealjey

interfaces/webcompiler.js

@@ -1,7 +1,8 @@
 /* @flow */
 
 import type {ProgramData, ProgramDataCallback, StringOrErrorCallback, ResultOrErrorCallback, LiveReloadTrigger,
-  ObjectOrErrorCallback, DevServerConfig, LintError, LintCallback, PostCSSWarning, NodeSassError} from '../src/typedef';
+  ObjectOrErrorCallback, DevServerConfig, LintError, LintCallback, PostCSSWarning, NodeSassError,
+  WatchCallback, JSCompilerConfig, SASSCompilerConfig} from '../src/typedef';
 
 declare module 'webcompiler' {
 
@@ -28,7 +29,7 @@ declare module 'webcompiler' {
   declare function highlightArray(code: ?string): Array<string | Object>;
   declare function highlightJSX(code: ?string): string;
 
-  declare function watch(dir: string, type: string, callback: () => void): void;
+  declare function watch(dir: string, type: string, callback: WatchCallback): void;
   declare function yaml(filename: string, callback: ObjectOrErrorCallback): void;
   declare function findBinary(name: string, callback: ResultOrErrorCallback): void;
   declare function livereload(): LiveReloadTrigger;
@@ -81,7 +82,7 @@ declare module 'webcompiler' {
   }
 
   declare class JSCompiler {
-    constructor(compress: ?boolean): void;
+    constructor(options: ?JSCompilerConfig): void;
     be(inPath: string, outPath: string, callback: ?() => void): void;
     fe(inPath: string, outPath: string, callback: ?() => void): void;
   }
@@ -92,15 +93,15 @@ declare module 'webcompiler' {
   }
 
   declare class SASSCompiler {
-    constructor(compress: ?boolean, includePaths: ?string[], importOnceOptions: ?Object): void;
+    constructor(options: ?SASSCompilerConfig): void;
     addPostcssPlugins(...plugins: any[]): SASSCompiler;
     postcss(path: string, data: ProgramData, callback: ProgramDataCallback): void;
     fe(inPath: string, outPath: string, callback: ?() => void): void;
   }
 
   declare class JS {
     compiler: JSCompiler;
-    constructor(compress: ?boolean, configFile: ?string): void;
+    constructor(options: ?JSCompilerConfig, configFile: ?string): void;
     typecheck(callback: () => void): void;
     lint(paths: string[], callback: () => void): void;
     be(inPath: string, outPath: string, lintPaths: ?string[], callback: ?() => void): void;
@@ -109,7 +110,7 @@ declare module 'webcompiler' {
 
   declare class SASS {
     compiler: SASSCompiler;
-    constructor(compress: ?boolean, includePaths: ?string[], configFile: ?string, importOnceOptions: ?Object): void;
+    constructor(options: ?SASSCompilerConfig, configFile: ?string): void;
     lint(paths: string[], callback: () => void): void;
     fe(inPath: string, outPath: string, lintPaths: ?string[], callback: ?() => void): void;
   }

src/Compiler.js

@@ -1,36 +1,40 @@
 /* @flow */
 
-import type {ProgramData, ProgramDataCallback} from './typedef';
+import type {ProgramData, ProgramDataCallback, CompilerConfig} from './typedef';
 import mkdirp from 'mkdirp';
 import {dirname} from 'path';
 import {writeFile, readFile} from 'fs';
 import {gzip, gunzip} from 'zlib';
 import {isProduction} from './util';
 import {logError, logSequentialSuccessMessage} from './logger';
 
+const defaultOptions = {
+  compress: isProduction
+};
+
 /**
  * The base compiler class
  *
  * @class Compiler
  * @abstract
- * @param {boolean} [compress=true] - if true `Compiler#save` will gzip compress the data in production mode
+ * @protected
+ * @param {CompilerConfig} [options={}] - configuration object
  */
 export class Compiler {
 
   /**
-   * if true `Compiler#save` will gzip compress the data
+   * configured options
    *
-   * @member {boolean} compress
+   * @member {CompilerConfig} options
    * @memberof Compiler
    * @private
    * @instance
    */
-  compress: boolean;
+  options: Object;
 
-  /* eslint-disable require-jsdoc */
-  constructor(compress: boolean = true) {
-    /* eslint-enable require-jsdoc */
-    this.compress = isProduction && compress;
+  // eslint-disable-next-line require-jsdoc
+  constructor(options: CompilerConfig = {}) {
+    this.options = {...defaultOptions, ...options};
   }
 
   /**
@@ -156,7 +160,7 @@ export class Compiler {
       readFile(`${path}.map`, 'utf8', (mapErr, mapData) => {
         const map = mapErr ? '' : mapData;
 
-        if (!this.compress) {
+        if (!this.options.compress) {
           return callback({code: scriptData.toString('utf8'), map});
         }
 
@@ -192,7 +196,7 @@ export class Compiler {
         map: oldData.map === data.map ? '' : data.map
       };
 
-      if (!this.compress) {
+      if (!this.options.compress) {
         Compiler.writeAndCallDone(inPath, outPath, newData, callback);
 
         return;

src/DevServer.js

@@ -64,16 +64,15 @@ export class DevServer {
   /**
    * optional configuration
    *
-   * @member {Object} options
+   * @member {DevServerConfig} options
    * @memberof DevServer
    * @private
    * @instance
    */
   options: Object;
 
-  /* eslint-disable require-jsdoc */
+  // eslint-disable-next-line require-jsdoc
   constructor(script: string, options: DevServerConfig = {}) {
-    /* eslint-enable require-jsdoc */
     this.script = script;
     this.options = {...defaultOptions, ...options};
   }
@@ -122,7 +121,7 @@ export class DevServer {
       return;
     }
 
-    const sass = new SASSCompiler(false),
+    const sass = new SASSCompiler({compress: false}),
       lr = livereload(),
       compileSASS = sass.fe.bind(sass, style, join(contentBase, 'style.css'), () => {
         lr('/style.css');

src/JS.js

@@ -1,5 +1,6 @@
 /* @flow */
 
+import type {JSCompilerConfig} from './typedef';
 import {JSCompiler} from './JSCompiler';
 import type {NativeProcess} from './NativeProcess';
 import {JSLint} from './JSLint';
@@ -13,9 +14,8 @@ import {findBinary} from './findBinary';
  * Wraps {@link JSCompiler} to add static analysis and linting. If you don't want that, use {@link JSCompiler} directly.
  *
  * @class JS
- * @param {boolean} [compress=true]                           - if true `Compiler#save` will gzip compress the data in
- *                                                              production mode
- * @param {string}  [configFile="webcompiler/.eslintrc.yaml"] - path to the ESLint configuration file
+ * @param {JSCompilerConfig} [options={}]                              - configuration object
+ * @param {string}           [configFile="webcompiler/.eslintrc.yaml"] - path to the ESLint configuration file
  * @example
  * import {JS} from 'webcompiler';
  * // or - import {JS} from 'webcompiler/lib/JS';
@@ -59,10 +59,9 @@ export class JS {
    */
   linter: JSLint;
 
-  /* eslint-disable require-jsdoc */
-  constructor(compress: boolean = true, configFile?: string) {
-    /* eslint-enable require-jsdoc */
-    this.compiler = new JSCompiler(compress);
+  // eslint-disable-next-line require-jsdoc
+  constructor(options?: JSCompilerConfig, configFile?: string) {
+    this.compiler = new JSCompiler(options);
     this.linter = new JSLint(configFile);
   }
 

src/JSCompiler.js

@@ -19,7 +19,7 @@ const {yellow, red} = consoleStyles;
  *
  * @class JSCompiler
  * @extends Compiler
- * @param {boolean} [compress=true] - if true `Compiler#save` will gzip compress the data in production mode
+ * @param {JSCompilerConfig} [options={}] - configuration object
  * @example
  * import {JSCompiler} from 'webcompiler';
  * // or - import {JSCompiler} from 'webcompiler/lib/JSCompiler';
@@ -178,7 +178,7 @@ export class JSCompiler extends Compiler {
    * @param {Function} [callback=function () {}] - a callback function
    */
   fe(inPath: string, outPath: string, callback: () => void = noop) {
-    const compiler = getCompiler(inPath, outPath);
+    const compiler = getCompiler(inPath, outPath, this.options);
 
     compiler.run((err, stats) => {
       if (err) {

src/SASS.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-import type {ImportOnceOptions} from './typedef';
+import type {SASSCompilerConfig} from './typedef';
 import {SASSCompiler} from './SASSCompiler';
 import {SASSLint} from './SASSLint';
 import noop from 'lodash/noop';
@@ -22,12 +22,8 @@ import {logLintingErrors} from './logger';
  * the module in JavaScript).
  *
  * @class SASS
- * @param {boolean}           [compress=true]                              - if true `Compiler#save` will gzip compress
- *                                                                           the data in production mode
- * @param {Array<string>}     [includePaths=[]]                            - an array of additional include paths
- * @param {string}            [configFile="webcompiler/.stylelintrc.yaml"] - path to the stylelint configuration file
- * @param {ImportOnceOptions} [importOnceOptions={}]                       - an object that lets you override default
- *                                                                           importOnce resolver configuration
+ * @param {SASSCompilerConfig} [options={}]                                 - configuration object
+ * @param {string}             [configFile="webcompiler/.stylelintrc.yaml"] - path to the stylelint configuration file
  * @example
  * import {SASS} from 'webcompiler';
  * // or - import {SASS} from 'webcompiler/lib/SASS';
@@ -65,11 +61,9 @@ export class SASS {
    */
   linter: SASSLint;
 
-  /* eslint-disable require-jsdoc */
-  constructor(compress: boolean = true, includePaths: string[] = [], configFile?: string,
-              importOnceOptions: ImportOnceOptions = {}) {
-    /* eslint-enable require-jsdoc */
-    this.compiler = new SASSCompiler(compress, includePaths, importOnceOptions);
+  // eslint-disable-next-line require-jsdoc
+  constructor(options?: SASSCompilerConfig, configFile?: string) {
+    this.compiler = new SASSCompiler(options);
     this.linter = new SASSLint(configFile);
   }
 

src/SASSCompiler.js

@@ -1,6 +1,6 @@
 /* @flow */
 
-import type {ProgramData, ProgramDataCallback, ImportOnceOptions} from './typedef';
+import type {ProgramData, ProgramDataCallback, SASSCompilerConfig} from './typedef';
 import {Compiler} from './Compiler';
 import {render} from 'node-sass';
 import importer from 'node-sass-import-once';
@@ -16,7 +16,11 @@ const precision = 8,
     'node_modules/font-awesome/scss',
     'node_modules',
     'node_modules/bootswatch'
-  ];
+  ],
+  defaultOptions = {
+    includePaths: [],
+    importOnce: {}
+  };
 
 /**
  * A SASS compiler
@@ -33,11 +37,7 @@ const precision = 8,
  *
  * @class SASSCompiler
  * @extends Compiler
- * @param {boolean}           [compress=true]        - if true `Compiler#save` will gzip compress the data in production
- *                                                     mode
- * @param {Array<string>}     [includePaths=[]]      - an array of additional include paths
- * @param {ImportOnceOptions} [importOnceOptions={}] - an object that lets you override default importOnce resolver
- *                                                     configuration
+ * @param {SASSCompilerConfig} [options={}] - configuration object
  * @example
  * import {SASSCompiler} from 'webcompiler';
  * // or - import {SASSCompiler} from 'webcompiler/lib/SASSCompiler';
@@ -55,26 +55,6 @@ const precision = 8,
  */
 export class SASSCompiler extends Compiler {
 
-  /**
-   * an array of paths to search for an scss file in if it's not found in cwd
-   *
-   * @member {Array<string>} includePaths
-   * @memberof SASSCompiler
-   * @private
-   * @instance
-   */
-  includePaths: string[];
-
-  /**
-   * importOnce resolver configuration
-   *
-   * @member {ImportOnceOptions} importOnce
-   * @memberof SASSCompiler
-   * @private
-   * @instance
-   */
-  importOnce: ImportOnceOptions;
-
   /**
    * postcss plugins
    *
@@ -85,12 +65,15 @@ export class SASSCompiler extends Compiler {
    */
   postcssPlugins: any[] = [autoprefixer];
 
-  /* eslint-disable require-jsdoc */
-  constructor(compress: boolean = true, includePaths: string[] = [], importOnceOptions: ImportOnceOptions = {}) {
-    /* eslint-enable require-jsdoc */
-    super(compress);
-    this.includePaths = defaultIncludePaths.concat(includePaths);
-    this.importOnce = {...importOnceDefaults, ...importOnceOptions};
+  // eslint-disable-next-line require-jsdoc
+  constructor(options: SASSCompilerConfig = {}) {
+    const {includePaths, importOnce, ...rest} = {...defaultOptions, ...options};
+
+    super({
+      includePaths: defaultIncludePaths.concat(includePaths),
+      importOnce: {...importOnceDefaults, ...importOnce},
+      ...rest
+    });
   }
 
   /**
@@ -144,13 +127,15 @@ export class SASSCompiler extends Compiler {
    * @param {Function} [callback=function () {}] - a callback function
    */
   fe(inPath: string, outPath: string, callback: () => void = noop) {
+    const {importOnce, includePaths} = this.options;
+
     render({
       file: inPath,
       outFile: outPath,
       importer,
       precision,
-      importOnce: this.importOnce,
-      includePaths: this.includePaths,
+      importOnce,
+      includePaths,
       sourceMap: true,
       sourceMapContents: true,
       outputStyle: 'compressed'