@videinfra/static-website-builder 2.0.2 → 2.0.4

package/lib/globs-helper.js

@@ -1,243 +1,243 @@
-import path from 'path';
-import flatten from 'lodash/flatten.js';
-import map from 'lodash/map.js';
-import filter from 'lodash/filter.js';
-
-const REGEX_DOT_PREFIX = /^\.+/;
-const REGEX_WINDOWS_BACKSLASH = /\\/g;
-
-class GlobObject {
-    constructor() {
-        this.hadEmptyPaths = false;
-        this.isIgnore = false;
-        this.isAllFiles = false;
-        this.hasExtensions = false;
-        this.extensions = [];
-        this.pathsArr = [];
-        this.pathsArrRaw = [];
-    }
-
-    paths(paths) {
-        const pathsArr = Array.isArray(paths) ? paths : typeof paths === 'string' ? [paths] : [];
-
-        if (pathsArr.length) {
-            if (this.pathsArr.length) {
-                this.map((basePath) => {
-                    return pathsArr.map((subPath) => {
-                        // If subpath starts with specia character "!" then prepend that to the begining of full paths
-                        const negativePath = subPath[0] === '!' ? '!' : '';
-                        const subPathNormalized = negativePath ? subPath.substr(1) : subPath;
-
-                        return negativePath + path.join(basePath, subPathNormalized);
-                    });
-                });
-
-                this.mapRaw((basePath) => {
-                    return pathsArr.map((subPath) => {
-                        // If subpath starts with specia character "!" then prepend that to the begining of full paths
-                        const negativePath = subPath[0] === '!' ? '!' : '';
-                        const subPathNormalized = negativePath ? subPath.substr(1) : subPath;
-
-                        if (negativePath) {
-                            this.isIgnore = true;
-                        }
-
-                        return negativePath + path.join(basePath, subPathNormalized);
-                    });
-                });
-            } else {
-                this.pathsArr = pathsArr;
-                this.pathsArrRaw = pathsArr;
-            }
-        } else {
-            this.hadEmptyPaths = true;
-        }
-
-        return this;
-    }
-
-    /**
-     * Adds extensions to the paths
-     *
-     * @param {string|array} extensions An extension or list of extensions
-     * @returns {object} GlobObject
-     */
-    filesWithExtensions(extensions) {
-        const extensionsArr = typeof extensions === 'string' ? [extensions] : extensions;
-
-        if (extensionsArr && extensionsArr.length) {
-            let extensionString = '';
-
-            // Remove dot from the extension name
-            let extensionsArrNormalized = map(extensionsArr, (extension) => extension.replace(REGEX_DOT_PREFIX, ''));
-
-            if (extensionsArrNormalized.length > 1) {
-                extensionString = `/**/*.{${extensionsArrNormalized.join(',')}}`;
-            } else {
-                extensionString = `/**/*.${extensionsArrNormalized}`;
-            }
-
-            this.extensions = this.extensions.concat(extensionsArr);
-            this.hasExtensions = !!this.extensions.length > 0;
-            return this.map((path) => `${path}${extensionString}`);
-        } else {
-            return this;
-        }
-    }
-
-    /**
-     * Add a wildcard to select all files
-     *
-     * @returns {object} GlobObject
-     */
-    allFiles() {
-        this.isAllFiles = true;
-        return this.map((path) => `${path}/**`);
-    }
-
-    /**
-     * Adds all paths to the ignore list
-     *
-     * @returns {object} GlobObject
-     */
-    ignore() {
-        this.isIgnore = true;
-        return this.map((path) => `!${path}`);
-    }
-
-    /**
-     * Itterates through all paths
-     *
-     * @param {function} fn Itteratee function
-     * @returns {object} GlobObject
-     */
-    map(fn) {
-        this.pathsArr = filter(flatten(map(this.pathsArr, fn)), (path) => !!path);
-        return this;
-    }
-
-    /**
-     * Itterates through all paths
-     *
-     * @param {function} fn Itteratee function
-     * @returns {object} GlobObject
-     */
-    mapRaw(fn) {
-        this.pathsArrRaw = filter(flatten(map(this.pathsArrRaw, fn)), (path) => !!path);
-        return this;
-    }
-
-    /**
-     * Converts paths to an array of normalized glob paths
-     *
-     * @returns {array} Array of glob paths
-     */
-    toArray() {
-        if (this.hadEmptyPaths && this.isIgnore) {
-            // Since we exclude files / paths, don't return anything if path list was empty
-            return [];
-        } else {
-            return map(this.pathsArr, (path) => {
-                return path.replace(REGEX_WINDOWS_BACKSLASH, '/');
-            });
-        }
-    }
-
-    /**
-     * Converts paths to an array of normalized glob paths
-     *
-     * @returns {array} Array of glob paths
-     */
-    toArrayRaw() {
-        if (this.hadEmptyPaths && this.isIgnore) {
-            // Since we exclude files / paths, don't return anything if path list was empty
-            return [];
-        } else {
-            return map(this.pathsArrRaw, (path) => {
-                return path.replace(REGEX_WINDOWS_BACKSLASH, '/');
-            });
-        }
-    }
-
-    /**
-     * Alias for toArray
-     *
-     * @returns {array} Array of glob paths
-     */
-    generate(forChokidar = false) {
-        if (forChokidar) {
-            const paths = this.toArrayRaw().map((path) => (this.isAllFiles || this.hasExtensions ? path + '/.' : path));
-
-            if (this.hadEmptyPaths && this.isIgnore) {
-                return {
-                    paths: [],
-                    ignore: [],
-                };
-            } else if (this.isIgnore) {
-                return {
-                    paths: paths,
-                    ignore: chokidarFilterIgnorePaths(this.toArrayRaw()),
-                };
-            } else if (this.hasExtensions) {
-                return {
-                    paths: paths,
-                    ignore: [chokidarFilterOnlyExtensions(this.extensions)],
-                };
-            } else {
-                return {
-                    paths: paths,
-                    ignore: [],
-                };
-            }
-        } else {
-            return this.toArray();
-        }
-    }
-}
-
-function paths(paths) {
-    return new GlobObject().paths(paths);
-}
-
-function generate(...globs) {
-    const isLastArgBoolean = typeof globs[globs.length - 1] === 'boolean';
-    const forChokidar = isLastArgBoolean ? globs.pop() : false;
-
-    if (forChokidar) {
-        const results = map(flatten(globs), (glob) => glob.generate(true));
-
-        return {
-            paths: flatten(results.map((result) => result.paths)),
-            ignore: flatten(results.map((result) => result.ignore)),
-        };
-    } else {
-        return flatten(map(flatten(globs), (glob) => glob.generate(false)));
-    }
-}
-
-/**
- * Create chokidar filter function to only allow certain extensions
- * @param {array} extensions
- * @returns {function}
- */
-function chokidarFilterOnlyExtensions(extensions) {
-    return function (path, _stats) {
-        return !extensions.some((extension) => path.endsWith(`.${extension}`));
-    };
-}
-
-/**
- * Create chokidar filter function to ignore certain paths
- * @param {array} ignorePaths
- * @returns {function}
- */
-function chokidarFilterIgnorePaths(ignorePaths) {
-    return function (path, _stats) {
-        return ignorePaths.some((ignorePath) => path.startsWith(ignorePath));
-    };
-}
-
-export default {
-    generate,
-    paths,
-};
+import path from 'path';
+import flatten from 'lodash/flatten.js';
+import map from 'lodash/map.js';
+import filter from 'lodash/filter.js';
+
+const REGEX_DOT_PREFIX = /^\.+/;
+const REGEX_WINDOWS_BACKSLASH = /\\/g;
+
+class GlobObject {
+    constructor() {
+        this.hadEmptyPaths = false;
+        this.isIgnore = false;
+        this.isAllFiles = false;
+        this.hasExtensions = false;
+        this.extensions = [];
+        this.pathsArr = [];
+        this.pathsArrRaw = [];
+    }
+
+    paths(paths) {
+        const pathsArr = Array.isArray(paths) ? paths : typeof paths === 'string' ? [paths] : [];
+
+        if (pathsArr.length) {
+            if (this.pathsArr.length) {
+                this.map((basePath) => {
+                    return pathsArr.map((subPath) => {
+                        // If subpath starts with specia character "!" then prepend that to the begining of full paths
+                        const negativePath = subPath[0] === '!' ? '!' : '';
+                        const subPathNormalized = negativePath ? subPath.substr(1) : subPath;
+
+                        return negativePath + path.join(basePath, subPathNormalized);
+                    });
+                });
+
+                this.mapRaw((basePath) => {
+                    return pathsArr.map((subPath) => {
+                        // If subpath starts with specia character "!" then prepend that to the begining of full paths
+                        const negativePath = subPath[0] === '!' ? '!' : '';
+                        const subPathNormalized = negativePath ? subPath.substr(1) : subPath;
+
+                        if (negativePath) {
+                            this.isIgnore = true;
+                        }
+
+                        return negativePath + path.join(basePath, subPathNormalized);
+                    });
+                });
+            } else {
+                this.pathsArr = pathsArr;
+                this.pathsArrRaw = pathsArr;
+            }
+        } else {
+            this.hadEmptyPaths = true;
+        }
+
+        return this;
+    }
+
+    /**
+     * Adds extensions to the paths
+     *
+     * @param {string|array} extensions An extension or list of extensions
+     * @returns {object} GlobObject
+     */
+    filesWithExtensions(extensions) {
+        const extensionsArr = typeof extensions === 'string' ? [extensions] : extensions;
+
+        if (extensionsArr && extensionsArr.length) {
+            let extensionString = '';
+
+            // Remove dot from the extension name
+            let extensionsArrNormalized = map(extensionsArr, (extension) => extension.replace(REGEX_DOT_PREFIX, ''));
+
+            if (extensionsArrNormalized.length > 1) {
+                extensionString = `/**/*.{${extensionsArrNormalized.join(',')}}`;
+            } else {
+                extensionString = `/**/*.${extensionsArrNormalized}`;
+            }
+
+            this.extensions = this.extensions.concat(extensionsArr);
+            this.hasExtensions = !!this.extensions.length > 0;
+            return this.map((path) => `${path}${extensionString}`);
+        } else {
+            return this;
+        }
+    }
+
+    /**
+     * Add a wildcard to select all files
+     *
+     * @returns {object} GlobObject
+     */
+    allFiles() {
+        this.isAllFiles = true;
+        return this.map((path) => `${path}/**`);
+    }
+
+    /**
+     * Adds all paths to the ignore list
+     *
+     * @returns {object} GlobObject
+     */
+    ignore() {
+        this.isIgnore = true;
+        return this.map((path) => `!${path}`);
+    }
+
+    /**
+     * Itterates through all paths
+     *
+     * @param {function} fn Itteratee function
+     * @returns {object} GlobObject
+     */
+    map(fn) {
+        this.pathsArr = filter(flatten(map(this.pathsArr, fn)), (path) => !!path);
+        return this;
+    }
+
+    /**
+     * Itterates through all paths
+     *
+     * @param {function} fn Itteratee function
+     * @returns {object} GlobObject
+     */
+    mapRaw(fn) {
+        this.pathsArrRaw = filter(flatten(map(this.pathsArrRaw, fn)), (path) => !!path);
+        return this;
+    }
+
+    /**
+     * Converts paths to an array of normalized glob paths
+     *
+     * @returns {array} Array of glob paths
+     */
+    toArray() {
+        if (this.hadEmptyPaths && this.isIgnore) {
+            // Since we exclude files / paths, don't return anything if path list was empty
+            return [];
+        } else {
+            return map(this.pathsArr, (path) => {
+                return path.replace(REGEX_WINDOWS_BACKSLASH, '/');
+            });
+        }
+    }
+
+    /**
+     * Converts paths to an array of normalized glob paths
+     *
+     * @returns {array} Array of glob paths
+     */
+    toArrayRaw() {
+        if (this.hadEmptyPaths && this.isIgnore) {
+            // Since we exclude files / paths, don't return anything if path list was empty
+            return [];
+        } else {
+            return map(this.pathsArrRaw, (path) => {
+                return path.replace(REGEX_WINDOWS_BACKSLASH, '/');
+            });
+        }
+    }
+
+    /**
+     * Alias for toArray
+     *
+     * @returns {array} Array of glob paths
+     */
+    generate(forChokidar = false) {
+        if (forChokidar) {
+            const paths = this.toArrayRaw().map((path) => (this.isAllFiles || this.hasExtensions ? path + '/.' : path));
+
+            if (this.hadEmptyPaths && this.isIgnore) {
+                return {
+                    paths: [],
+                    ignore: [],
+                };
+            } else if (this.isIgnore) {
+                return {
+                    paths: paths,
+                    ignore: chokidarFilterIgnorePaths(this.toArrayRaw()),
+                };
+            } else if (this.hasExtensions) {
+                return {
+                    paths: paths,
+                    ignore: [chokidarFilterOnlyExtensions(this.extensions)],
+                };
+            } else {
+                return {
+                    paths: paths,
+                    ignore: [],
+                };
+            }
+        } else {
+            return this.toArray();
+        }
+    }
+}
+
+function paths(paths) {
+    return new GlobObject().paths(paths);
+}
+
+function generate(...globs) {
+    const isLastArgBoolean = typeof globs[globs.length - 1] === 'boolean';
+    const forChokidar = isLastArgBoolean ? globs.pop() : false;
+
+    if (forChokidar) {
+        const results = map(flatten(globs), (glob) => glob.generate(true));
+
+        return {
+            paths: flatten(results.map((result) => result.paths)),
+            ignore: flatten(results.map((result) => result.ignore)),
+        };
+    } else {
+        return flatten(map(flatten(globs), (glob) => glob.generate(false)));
+    }
+}
+
+/**
+ * Create chokidar filter function to only allow certain extensions
+ * @param {array} extensions
+ * @returns {function}
+ */
+function chokidarFilterOnlyExtensions(extensions) {
+    return function (path, _stats) {
+        return !extensions.some((extension) => path.endsWith(`.${extension}`));
+    };
+}
+
+/**
+ * Create chokidar filter function to ignore certain paths
+ * @param {array} ignorePaths
+ * @returns {function}
+ */
+function chokidarFilterIgnorePaths(ignorePaths) {
+    return function (path, _stats) {
+        return ignorePaths.some((ignorePath) => path.startsWith(ignorePath));
+    };
+}
+
+export default {
+    generate,
+    paths,
+};

package/lib/gulp/dynamic-task.js

@@ -1,8 +1,8 @@
-/**
- * Similar to parallel() and serial() but instead of getting tasks immediatelly
- * it's executed after config has been loaded
- */
-export default function dynamicTask (fn) {
-    fn.dynamicTasks = true;
-    return fn;
-}
+/**
+ * Similar to parallel() and serial() but instead of getting tasks immediatelly
+ * it's executed after config has been loaded
+ */
+export default function dynamicTask (fn) {
+    fn.dynamicTasks = true;
+    return fn;
+}

package/lib/gulp/resolve-dynamic-task.js

@@ -1,11 +1,11 @@
-/**
- * Similar to parallel() and serial() but instead of getting tasks immediatelly
- * it's executed after config has been loaded
- */
-export default function resolveDynamicTask (fn) {
-    if (fn.dynamicTasks) {
-        return fn();
-    } else {
-        return fn;
-    }
-}
+/**
+ * Similar to parallel() and serial() but instead of getting tasks immediatelly
+ * it's executed after config has been loaded
+ */
+export default function resolveDynamicTask (fn) {
+    if (fn.dynamicTasks) {
+        return fn();
+    } else {
+        return fn;
+    }
+}

package/lib/gulp/task-before-dest.js

@@ -1,8 +1,8 @@
-import plumber  from 'gulp-plumber';
-
-/**
- * Gulp task pipe function which handles errors
- */
-export default function taskBeforeDest () {
-    return plumber.stop();
-}
+import plumber  from 'gulp-plumber';
+
+/**
+ * Gulp task pipe function which handles errors
+ */
+export default function taskBeforeDest () {
+    return plumber.stop();
+}

package/lib/gulp/task-end.js

@@ -1,10 +1,10 @@
-import gulpif  from 'gulp-if';
-import { getTaskConfig } from '../get-config.js';
-import browserSync  from 'browser-sync';
-
-/**
- * Gulp task pipe function which handles browsersync reloading
- */
-export default function taskEnd () {
-    return gulpif(!!getTaskConfig('browserSync'), browserSync.stream());
-};
+import gulpif  from 'gulp-if';
+import { getTaskConfig } from '../get-config.js';
+import browserSync  from 'browser-sync';
+
+/**
+ * Gulp task pipe function which handles browsersync reloading
+ */
+export default function taskEnd () {
+    return gulpif(!!getTaskConfig('browserSync'), browserSync.stream());
+};

package/lib/gulp/task-start.js

@@ -1,12 +1,12 @@
-import plumber  from 'gulp-plumber';
-import logError  from '../log-error.js';
-
-/**
- * Gulp task pipe function which handles errors
- */
-export default function taskStart () {
-    return plumber(function (error) {
-        // Fail whole gulp process if in production mode
-        logError.call(this, error, global.production);
-    });
-}
+import plumber  from 'gulp-plumber';
+import logError  from '../log-error.js';
+
+/**
+ * Gulp task pipe function which handles errors
+ */
+export default function taskStart () {
+    return plumber(function (error) {
+        // Fail whole gulp process if in production mode
+        logError.call(this, error, global.production);
+    });
+}