@videinfra/static-website-builder 1.17.0 → 2.0.0-beta.1

package/tasks/static/task.js

@@ -1,5 +1,5 @@
 const gulp = require('gulp');
-const memoize = require('nano-memoize');
+const { nanomemoize } = require('nano-memoize');
 
 const globs = require('./../../lib/globs-helper');
 const getPaths = require('./../../lib/get-path');
@@ -11,14 +11,18 @@ const taskBeforeDest = require('../../lib/gulp/task-before-dest');
 const taskWatch = require('../../lib/gulp/task-watch');
 
 
-const getGlobPaths = memoize(function () {
+const getWatchGlobPaths = function (forChokidar = false) {
     const sourcePaths = getPaths.getSourcePaths('static');
     const ignore = getConfig.getTaskConfig('static', 'ignore');
 
     return globs.generate(
         globs.paths(sourcePaths).allFiles(),             // Files to watch
         globs.paths(sourcePaths).paths(ignore).ignore(), // List of files which to ignore
+        forChokidar,
     );
+};
+const getGlobPaths = nanomemoize(function () {
+    return getWatchGlobPaths(false);
 });
 
 
@@ -35,7 +39,7 @@ function static () {
 }
 
 function staticWatch () {
-    return taskWatch(getGlobPaths(), static);
+    return taskWatch(getWatchGlobPaths(true), static);
 }
 
 

package/tasks/stylesheets/task.js

@@ -2,7 +2,7 @@ const gulp = require('gulp');
 const gulpif = require('gulp-if');
 const postcss = require('gulp-postcss');
 const sourcemaps = require('gulp-sourcemaps');
-const memoize = require('nano-memoize');
+const { nanomemoize } = require('nano-memoize');
 const cached = require('gulp-cached');
 const dependents = require('gulp-dependents');
 
@@ -16,7 +16,7 @@ const taskBeforeDest = require('../../lib/gulp/task-before-dest');
 const taskWatch = require('../../lib/gulp/task-watch');
 
 
-const getGlobPaths = memoize(function () {
+const getWatchGlobPaths = function (forChokidar = false) {
     const sourcePaths = getPaths.getSourcePaths('stylesheets');
     const extensions = getConfig.getTaskConfig('stylesheets', 'extensions');
     const ignore = getConfig.getTaskConfig('stylesheets', 'ignore');
@@ -24,18 +24,22 @@ const getGlobPaths = memoize(function () {
     return globs.generate(
         globs.paths(sourcePaths).filesWithExtensions(extensions), // Files to watch
         globs.paths(sourcePaths).paths(ignore).ignore(),          // List of files which to ignore
+        forChokidar,
     );
+};
+
+const getGlobPaths = nanomemoize(function () {
+    return getWatchGlobPaths(false);
 });
 
 
-const getEngine = memoize(function () {
+const getEngine = function () {
     const engine = getConfig.getTaskConfig('stylesheets', 'engine');
     return engine ? engine() : (() => {});
-});
+};
 
 
 function stylesheets () {
-    // console.log(getConfig.getTaskConfig('stylesheets', 'dependents'));
     return gulp.src(getGlobPaths())
         .pipe(taskStart())
 
@@ -61,7 +65,7 @@ function stylesheets () {
 }
 
 function stylesheetsWatch () {
-    return taskWatch(getGlobPaths(), stylesheets);
+    return taskWatch(getWatchGlobPaths(true), stylesheets);
 }
 
 

package/tests/build/build.test.js

@@ -64,10 +64,7 @@ test('Font file fake not copied', () => {
 test('shared.js file exists', () => {
     return Promise.all([
         fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/shared.js'), {'encoding': 'utf8'}).then((js) => {
-            expect(js.indexOf('console.log("Shared file loaded")')).not.toBe(-1);
-        }),
-        fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/alt/shared.js'), {'encoding': 'utf8'}).then((js) => {
-            expect(js.indexOf('console.log("Shared file loaded")')).not.toBe(-1);
+            expect(js.indexOf('console.log(`Shared file loaded`)')).not.toBe(-1);
         }),
     ]);
 });
@@ -75,20 +72,28 @@ test('shared.js file exists', () => {
 test('main.js file exists', () => {
     return Promise.all([
         fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/main.js'), {'encoding': 'utf8'}).then((js) => {
-            expect(js.indexOf('console.log("Hello from main page!")')).not.toBe(-1);
+            expect(js.indexOf('console.log(`Hello from main page!`')).not.toBe(-1);
         }),
         fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/alt/main.js'), {'encoding': 'utf8'}).then((js) => {
-            expect(js.indexOf('console.log("Hello from main page!")')).not.toBe(-1);
+            expect(js.indexOf('console.log(`Hello from main page!`')).not.toBe(-1);
         }),
     ]);
 });
 
 test('other.js file exists', () => {
     return fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/other.js'), {'encoding': 'utf8'}).then((js) => {
-        expect(js.indexOf('console.log("Hello from other page!")')).not.toBe(-1);
+        expect(js.indexOf('console.log(`Hello from other page!`)')).not.toBe(-1);
     });
 });
 
+test('something.ts was converted', () => {
+    return Promise.all([
+        fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/something.js'), {'encoding': 'utf8'}).then((js) => {
+            expect(js.indexOf('console.log({name:`something`})')).not.toBe(-1);
+        }),
+    ]);
+});
+
 test('alt/other.js file doesn\'t exist', async () => {
     expect(fsPromises.stat(path.resolve(publicPath, 'assets/javascripts/alt/other.js'))).rejects.toThrow();
 });
@@ -96,12 +101,12 @@ test('alt/other.js file doesn\'t exist', async () => {
 test('.env and .env.local files loaded', () => {
     return Promise.all([
         fsPromises.readFile(path.resolve(publicPath, 'assets/javascripts/main.js'), {'encoding': 'utf8'}).then((js) => {
-            expect(js.indexOf('console.log("env.host ==","https://test-local.tld")')).not.toBe(-1);
-            expect(js.indexOf('console.log("env.foo ==","foo-global")')).not.toBe(-1);
-            expect(js.indexOf('console.log("env.bar ==","bar-local")')).not.toBe(-1);
-            expect(js.indexOf('console.log("env.typeBoolTrue ==",!0)')).not.toBe(-1);
-            expect(js.indexOf('console.log("env.typeBoolFalse ==",!1)')).not.toBe(-1);
-            expect(js.indexOf('console.log("env.typeNumber ==",123.456)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.host ==`,`https://test-local.tld`)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.foo ==`,`foo-global`)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.bar ==`,`bar-local`)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.typeBoolTrue ==`,!0)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.typeBoolFalse ==`,!1)')).not.toBe(-1);
+            expect(js.indexOf('console.log(`env.typeNumber ==`,123.456)')).not.toBe(-1);
         }),
         fsPromises.readFile(path.resolve(publicPath, 'env.html'), {'encoding': 'utf8'}).then((html) => {
             expect(html.indexOf('<p>HOST: https://test-local.tld</p>')).not.toBe(-1);

package/vendor/gulp-rolldown/index.js

@@ -0,0 +1,184 @@
+const Transform = require('stream').Transform
+const PluginError = require('plugin-error')
+
+const PLUGIN_NAME = 'gulp-starter-rolldown'
+const rolldown = require('rolldown');
+const browserSync = require('browser-sync');
+
+/**
+ * Evaluate entry file
+ *
+ * @param {string} code Entry file code
+ * @returns {object} Entry file object
+ */
+function evalEntry(code) {
+    const fullCode = `let _return = {};
+    ${code.replace(/\bexport\b[\s\t\r\n]*([^\s\t]+)/g, '_return.$1 =')}
+    return _return;`;
+
+    const result = new Function(fullCode)();
+    if (result.default) {
+        Object.assign(result, result.default);
+        delete result.default;
+    }
+
+    return result;
+}
+
+/**
+ * Virtual entry plugin to generate files from each of the entries in the entry file
+ *
+ * @param {object} entries Entries object from the entry file
+ * @returns {object} Virtual entry plugin
+ */
+function virtualEntryPlugin(entries) {
+    const keys = Object.keys(entries);
+
+    return {
+        name: 'virtual-entry-plugin', // this name will show up in logs and errors
+
+        resolveId: {
+			order: 'post',
+			handler(source) {
+				if (keys.includes(source)) {
+                    return source;
+                }
+                return null; // other ids should be handled as usual
+			}
+		},
+
+        load(id) {
+            if (keys.includes(id)) {
+                return entries[id].map((entry) => `import '${entry}';`).join('\n');
+            }
+            return null; // other ids should be handled as usual
+        },
+    };
+}
+
+const watcherList = {};
+
+// transformer class
+class GulpRolldown extends Transform {
+
+    _build(file, cb, inputOptions, outputOptions) {
+        rolldown.build(inputOptions)
+            .then((result) => {
+                // Prevent gulp from outputing anything
+                cb();
+            })
+            .catch(err => {
+                process.nextTick(() => {
+                    this.emit('error', new PluginError(PLUGIN_NAME, err))
+                    cb()
+                });
+            });
+    }
+
+    _watch(file, cb, inputOptions, outputOptions) {
+        const watcher = watcherList[file.path] = rolldown.watch(inputOptions);
+
+        watcher.on('event', (event) => {
+            if (event.code === 'BUNDLE_END') {
+                event.result.close();
+
+                // Reload browser
+                browserSync.reload();
+            }
+        });
+
+        // Prevent gulp from outputing anything
+        cb();
+    }
+
+    _transform(file, encoding, cb) {
+        // Empty or unavailable files, not supported
+        if (file.isNull()) {
+            return cb(null, file)
+        }
+
+        // Stream, not supported
+        if (file.isStream()) {
+            return cb(new PluginError(PLUGIN_NAME, 'Streaming not supported'))
+        }
+
+        const entries = this.inputOptions.entries;
+
+        if (!file.path.endsWith(entries.name)) {
+            // Not an entry file, skip
+            return cb();
+        }
+
+        // Remove old watcher if exists
+        if (watcherList[file.path]) {
+            watcherList[file.path].close();
+            delete watcherList[file.path];
+        }
+
+        // Transform options
+        const fullDir = this.outputOptions.fullDir;
+        const inputOptions = Object.assign({}, this.inputOptions)
+        const outputOptions = Object.assign({}, this.outputOptions);
+
+        delete(inputOptions.entries);
+        delete(outputOptions.fullDir);
+
+        // Parse entry file
+        const entryContent = evalEntry(file.contents.toString());
+        if (!entryContent) {
+            // @TODO Couldn't read entry file, throw an error???
+        }
+
+        // Add code splitting with shared
+        if (entries.shared) {
+            outputOptions.codeSplitting = Object.assign({}, outputOptions.codeSplitting || {}, {
+                groups: [].concat(outputOptions.codeSplitting?.groups || [], [
+                    {
+                        name: entries.shared,
+                        minShareCount: 3,
+                    },
+                ]),
+            });
+        }
+
+        // Don't output hash for rolldown runtime and shared chunks
+        outputOptions.chunkFileNames = (info) => {
+            if ((entries.shared && info.name === entries.shared) || info.name === 'rolldown-runtime') {
+                return '[name].js';
+            } else {
+                return '[name]-[hash].js';
+            }
+        };
+
+        // Set input files
+        inputOptions.input = Object.keys(entryContent);
+        inputOptions.plugins = [
+            virtualEntryPlugin(entryContent),
+        ].concat(inputOptions.plugins || []);
+
+        // Set full paths when running watch or build
+        inputOptions.output = outputOptions;
+
+        if (global.production) {
+            this._build(file, cb, inputOptions);
+        } else {
+            this._watch(file, cb, inputOptions);
+        }
+    }
+}
+
+/**
+ * Factory
+ *
+ * @param {object} inputOptions
+ * @param {object} outputOptions
+ * @returns
+ */
+module.exports = function factory(inputOptions, outputOptions) {
+    const stream = new GulpRolldown({objectMode: true})
+
+    stream.inputOptions = inputOptions
+    stream.outputOptions = outputOptions
+
+    return stream
+}

package/tasks/javascripts/webpack-url-version.js

@@ -1,32 +0,0 @@
-/**
- * Plugin which adds to the dynamically imported JS files a version string at the end
- * which is the same as for original file name.
- */
-module.exports = class WebpackURLVersioningPlugin {
-    apply(compiler) {
-        compiler.hooks.afterPlugins.tap('URLVersioning', () => {
-            compiler.hooks.thisCompilation.tap('URLVersioning', compilation => {
-                const mainTemplate = compilation.mainTemplate;
-
-                if (mainTemplate.hooks.localVars) {
-                    mainTemplate.hooks.localVars.tap('URLVersioning',(source, _chunk, _hash) => {
-                        if (source.indexOf('var version = ') === -1) {
-                            const startString = 'function jsonpScriptSrc(chunkId) {';
-                            const endString = '+ ".js"';
-                            const start = source.indexOf(startString);
-                            const end = start !== -1 ? source.indexOf(endString, start) : -1;
-
-                            if (start !== -1) {
-                                const offset = end + endString.length;
-                                return 'var version = document.currentScript.src && document.currentScript.src.match(/\\?.*/);' + source.substr(0, offset) + ' + (version ? version[0] : "")' + source.substr(offset);
-                            }
-                        }
-
-                        return source;
-                    });
-                }
-            });
-        });
-
-    }
-}

package/vendor/webpack-stream/index.js

@@ -1,253 +0,0 @@
-// 2024-02-24, Kaspars Zuks: added support for dynamic entries (entry as a function)
-'use strict';
-
-var fancyLog = require('fancy-log');
-var PluginError = require('plugin-error');
-var supportsColor = require('supports-color');
-var File = require('vinyl');
-var MemoryFileSystem = require('memory-fs');
-var nodePath = require('path');
-var through = require('through');
-var ProgressPlugin = require('webpack/lib/ProgressPlugin');
-var clone = require('lodash.clone');
-
-var defaultStatsOptions = {
-  colors: supportsColor.stdout.hasBasic,
-  hash: false,
-  timings: false,
-  chunks: false,
-  chunkModules: false,
-  modules: false,
-  children: true,
-  version: true,
-  cached: false,
-  cachedAssets: false,
-  reasons: false,
-  source: false,
-  errorDetails: false
-};
-
-module.exports = function (options, wp, done) {
-  options = clone(options) || {};
-  var config = options.config || options;
-  var cache = {};
-
-  // Webpack 4 doesn't support the `quiet` attribute, however supports
-  // setting `stats` to a string within an array of configurations
-  // (errors-only|minimal|none|normal|verbose) or an object with an absurd
-  // amount of config
-  const isSilent = options.quiet || (typeof options.stats === 'string' && (options.stats.match(/^(errors-only|minimal|none)$/)));
-
-  if (typeof done !== 'function') {
-    var callingDone = false;
-    done = function (err, stats) {
-      if (err) {
-        // The err is here just to match the API but isnt used
-        return;
-      }
-      stats = stats || {};
-      if (isSilent || callingDone) {
-        return;
-      }
-
-      // Debounce output a little for when in watch mode
-      if (options.watch) {
-        callingDone = true;
-        setTimeout(function () {
-          callingDone = false;
-        }, 500);
-      }
-
-      if (options.verbose) {
-        fancyLog(stats.toString({
-          colors: supportsColor.stdout.hasBasic
-        }));
-      } else {
-        var statsOptions = (options && options.stats) || {};
-
-        if (typeof statsOptions === 'object') {
-          Object.keys(defaultStatsOptions).forEach(function (key) {
-            if (typeof statsOptions[key] === 'undefined') {
-              statsOptions[key] = defaultStatsOptions[key];
-            }
-          });
-        }
-        var statusLog = stats.toString(statsOptions);
-        if (statusLog) {
-          fancyLog(statusLog);
-        }
-      }
-    };
-  }
-
-  var webpack = wp || require('webpack');
-  var entry = [];
-  var entries = Object.create(null);
-
-  var stream = through(function (file) {
-    if (file.isNull()) {
-      return;
-    }
-    if ('named' in file) {
-      if (!Array.isArray(entries[file.named])) {
-        entries[file.named] = [];
-      }
-      entries[file.named].push(file.path);
-    } else {
-      entry = entry || [];
-      entry.push(file.path);
-    }
-  }, function () {
-    var self = this;
-    var handleConfig = function (config) {
-      config.output = config.output || {};
-      config.watch = !!options.watch;
-
-      // Determine pipe'd in entry
-      if (Object.keys(entries).length > 0) {
-        entry = entries;
-        if (!config.output.filename) {
-          // Better output default for multiple chunks
-          config.output.filename = '[name].js';
-        }
-      } else if (entry.length < 2) {
-        entry = entry[0] || entry;
-      }
-
-      config.entry = config.entry || entry;
-      config.output.path = config.output.path || process.cwd();
-      config.output.filename = config.output.filename || '[hash].js';
-      config.watch = options.watch;
-      entry = [];
-
-      if (typeof config.entry !== 'function' && (!config.entry || config.entry.length < 1)) {
-        fancyLog('webpack-stream - No files given; aborting compilation');
-        self.emit('end');
-        return false;
-      }
-      return true;
-    };
-
-    var succeeded;
-    if (Array.isArray(config)) {
-      for (var i = 0; i < config.length; i++) {
-        succeeded = handleConfig(config[i]);
-        if (!succeeded) {
-          return false;
-        }
-      }
-    } else {
-      succeeded = handleConfig(config);
-      if (!succeeded) {
-        return false;
-      }
-    }
-
-    // Cache compiler for future use
-    var compiler = cache.compiler || webpack(config);
-    cache.compiler = compiler;
-
-    const callback = function (err, stats) {
-      if (err) {
-        self.emit('error', new PluginError('webpack-stream', err));
-        return;
-      }
-      var jsonStats = stats ? stats.toJson() || {} : {};
-      var errors = jsonStats.errors || [];
-      if (errors.length) {
-        var errorMessage = errors.join('\n');
-        var compilationError = new PluginError('webpack-stream', errorMessage);
-        if (!options.watch) {
-          self.emit('error', compilationError);
-        }
-        self.emit('compilation-error', compilationError);
-      }
-      if (!options.watch) {
-        self.queue(null);
-      }
-      done(err, stats);
-      if (options.watch && !isSilent) {
-        fancyLog('webpack is watching for changes');
-      }
-    };
-
-    if (options.watch) {
-      const watchOptions = options.watchOptions || {};
-      compiler.watch(watchOptions, callback);
-    } else {
-      compiler.run(callback);
-    }
-
-    var handleCompiler = function (compiler) {
-      if (options.progress) {
-        (new ProgressPlugin(function (percentage, msg) {
-          percentage = Math.floor(percentage * 100);
-          msg = percentage + '% ' + msg;
-          if (percentage < 10) msg = ' ' + msg;
-          fancyLog('webpack', msg);
-        })).apply(compiler);
-      }
-
-      cache.mfs = cache.mfs || new MemoryFileSystem();
-
-      var fs = compiler.outputFileSystem = cache.mfs;
-
-      var afterEmitPlugin = compiler.hooks
-        // Webpack 4
-        ? function (callback) { compiler.hooks.afterEmit.tapAsync('WebpackStream', callback); }
-        // Webpack 2/3
-        : function (callback) { compiler.plugin('after-emit', callback); };
-
-      afterEmitPlugin(function (compilation, callback) {
-        Object.keys(compilation.assets).forEach(function (outname) {
-          if (compilation.assets[outname].emitted) {
-            var file = prepareFile(fs, compiler, outname);
-            self.queue(file);
-          }
-        });
-        callback();
-      });
-    };
-
-    if (Array.isArray(options.config)) {
-      compiler.compilers.forEach(function (compiler) {
-        handleCompiler(compiler);
-      });
-    } else {
-      handleCompiler(compiler);
-    }
-  });
-
-  // If entry point manually specified, trigger that
-  var hasEntry = Array.isArray(config)
-    ? config.some(function (c) { return c.entry; })
-    : config.entry;
-  if (hasEntry) {
-    stream.end();
-  }
-
-  return stream;
-};
-
-function prepareFile (fs, compiler, outname) {
-  var path = fs.join(compiler.outputPath, outname);
-  if (path.indexOf('?') !== -1) {
-    path = path.split('?')[0];
-  }
-
-  var contents = fs.readFileSync(path);
-
-  var file = new File({
-    base: compiler.outputPath,
-    path: nodePath.join(compiler.outputPath, outname),
-    contents: contents
-  });
-  return file;
-}
-
-// Expose webpack if asked
-Object.defineProperty(module.exports, 'webpack', {
-  get: function () {
-    return require('webpack');
-  }
-});