ultimate-jekyll-manager 0.0.1 → 0.0.3

package/dist/gulp/main.js

@@ -0,0 +1,82 @@
+// Libraries
+const path = require('path');
+const jetpack = require('fs-jetpack');
+const { series, parallel, watch } = require('gulp');
+const Manager = new (require('../index.js'));
+const logger = Manager.logger('main');
+
+// Load tasks
+const tasks = jetpack.list(path.join(__dirname, 'tasks'));
+
+// Log
+// logger.log('---tasks 1', path.join(__dirname, 'tasks'));
+// logger.log('---tasks 2', tasks);
+
+// Init global
+global.tasks = {};
+global.browserSync = null;
+
+// Load tasks
+tasks.forEach((file) => {
+  const name = file.replace('.js', '');
+
+  // Log
+  // logger.log('Loading task:', name);
+
+  // Export task
+  exports[name] = require(path.join(__dirname, 'tasks', file));
+});
+
+// Log tasks
+// logger.log('exports:', exports);
+
+// Set global variable to access tasks in other files
+global.tasks = exports;
+
+// Define build process
+exports.build = series(
+  parallel(exports.sass, exports.webpack, exports.imagemin),
+  exports.jekyll,
+);
+
+// Watch for changes
+exports.watcher = function watcher() {
+  watch(
+    [
+      // Files to include
+      'site/**/*',
+      // '**/*.html',
+      // '**/*.md',
+      // '**/*.yml',
+      // '**/*.scss',
+      // '**/*.js',
+
+      // Files to exclude
+      '!_site/**',
+      '!site/.jekyll-cache/**',
+      '!site/.jekyll-metadata',
+      // '!site/compiled/**',
+      // '!./node_modules/**/*',
+    ],
+    { delay: 500 },
+    series(exports.jekyll, (complete) => {
+      // Log
+      logger.log('Reloading browser...');
+
+      // Reload
+      global.browserSync.notify('Rebuilt Jekyll');
+      global.browserSync.reload();
+
+      // Complete
+      return complete();
+    })
+  );
+}
+
+// Compose task scheduler
+exports.default = series(
+  exports.build,
+  exports.serve,
+  exports.watcher,
+);
+

package/dist/gulp/tasks/imagemin.js

@@ -0,0 +1,110 @@
+// Libraries
+const path = require('path');
+const { src, dest, watch, series } = require('gulp');
+const glob = require('glob').globSync;
+const responsive = require('gulp-responsive-modern');
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('imagemin');
+
+// Glob
+const input = [
+  // Files to include
+  'site/assets/images/**/*.{jpg,jpeg,png}',
+
+  // Files to exclude
+  // '!site/compiled/**',
+];
+const output = 'site/compiled/images';
+
+// IMAGES Processing Task
+function imagemin(complete) {
+  // Log
+  logger.log('Starting image processing...');
+
+  // Use glob to get file count for msdtching files
+  const files = glob(input);
+
+  // If there's no files, complete
+  if (files.length === 0) {
+    // Log
+    logger.log('No images to process');
+
+    // Complete
+    return complete();
+  }
+
+  // Process images: resize and convert to webp
+  return src(input)
+    .pipe(
+      responsive({
+        '**/*.{jpg,jpeg,png}': [
+          // 1024 resized version in original format
+          {
+            width: 1024,
+            rename: { suffix: '-1024px' }
+          },
+          // 1024 resized webp version
+          {
+            width: 1024,
+            format: 'webp',
+            rename: { suffix: '-1024px' }
+          },
+          // Mobile resized version (e.g., 640px wide) in original format
+          {
+            width: 425,
+            rename: { suffix: '-425px' }
+          },
+          // Mobile resized webp version
+          {
+            width: 425,
+            format: 'webp',
+            rename: { suffix: '-425px' }
+          },
+          // Original size webp version
+          {
+            format: 'webp',
+            rename: { suffix: '' }
+          },
+          // Original size in original format
+          {
+            rename: { suffix: '' }
+          }
+        ]
+      }, {
+        quality: 80,
+        progressive: true,
+        withMetadata: false,
+        withoutEnlargement: false,
+        skipOnEnlargement: false,
+      })
+    )
+    .pipe(dest(output))
+    .on('end', () => {
+      // Log
+      logger.log('Finished image processing!');
+
+      // Complete
+      return complete();
+    });
+}
+
+// Watcher Task
+function imageminWatcher(complete) {
+  // Quit if in build mode
+  if (process.env.UJ_BUILD_MODE === 'true') {
+    logger.log('Skipping image watcher in build mode');
+    return complete();
+  }
+
+  // Log
+  logger.log('Watching for image changes...');
+
+  // Watch for changes
+  watch(input, { delay: 250 }, imagemin);
+
+  // Complete
+  return complete();
+}
+
+// Default Task
+module.exports = series(imagemin, imageminWatcher);

package/dist/gulp/tasks/jekyll.js

@@ -0,0 +1,82 @@
+// Libraries
+const path = require('path');
+const { execute } = require('node-powertools');
+const jetpack = require('fs-jetpack');
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('jekyll');
+
+// Set index
+let index = -1;
+
+// Hooks
+const hooks = {
+  prebuild: loadHook('prebuild'),
+  postbuild: loadHook('postbuild'),
+}
+
+// Task
+module.exports = async function jekyll(complete) {
+  // Log
+  logger.log('Starting Jekyll build...');
+
+  // Increment index
+  index++;
+
+  // Clean if on index 0
+  if (index === 0) {
+    await execute('npx uj clean', {log: true});
+  }
+
+  // Wait 5 seconds
+  // await new Promise((resolve) => setTimeout(resolve, 5000));
+
+  // Run prebuild hook
+  await hooks.prebuild(index);
+
+  // Build Jekyll
+  const command = [
+    'bundle exec jekyll build',
+    '--source site',
+    '--config ./node_modules/ultimate-jekyll-manager/dist/config/_config_main.yml,site/_config.yml,.temp/_config_browsersync.yml',
+    '--incremental',
+  ]
+
+  // Log command
+  logger.log(`Running command: ${logger.format.gray(command.join(' '))}`);
+
+  // Build Jekyll
+  await execute(command.join(' '), {log: true});
+
+  // Run postbuild hook
+  await hooks.postbuild(index);
+
+  // Log
+  logger.log('Finished Jekyll build!');
+
+  // Complete
+  return complete();
+};
+
+
+function loadHook(file) {
+  // Full path
+  const fullPath = path.join(process.cwd(), 'hooks', `${file}.js`);
+
+  // Log
+  // logger.log(`Loading hook: ${fullPath}`);
+
+  try {
+    // Check if it exists
+    if (!jetpack.exists(fullPath)) {
+      throw new Error('Hook not found');
+    }
+
+    return require(fullPath);
+  } catch (e) {
+    // Log
+    logger.error(`Error executing hook: ${fullPath}`, e);
+
+    // Return a noop function
+    return () => {};
+  }
+}

package/dist/gulp/tasks/sass.js

@@ -0,0 +1,57 @@
+// Libraries
+const path = require('path');
+const { src, dest, watch, series } = require('gulp');
+const compiler = require('gulp-sass')(require('sass'));
+const cleanCSS = require('gulp-clean-css');
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('sass');
+
+// Glob
+const input = [
+  // Files to include
+  'site/assets/css/**/*.{css,scss,sass}',
+
+  // Files to exclude
+  // '!site/compiled/**',
+];
+const output = 'site/compiled/css';
+
+// SASS Compilation Task
+function sass(complete) {
+  // Log
+  logger.log('Starting SASS compilation...');
+
+  // Compile
+  return src(input)
+    .pipe(compiler({ outputStyle: 'compressed' }).on('error', compiler.logError))
+    .pipe(cleanCSS())
+    .pipe(dest(output))
+    .on('end', () => {
+      // Log
+      logger.log('Finished SASS compilation');
+
+      // Complete
+      return complete();
+    });
+}
+
+// Watcher Task
+function sassWatcher(complete) {
+  // Quit if in build mode
+  if (process.env.UJ_BUILD_MODE === 'true') {
+    logger.log('Skipping SASS watcher in build mode');
+    return complete();
+  }
+
+  // Log
+  logger.log('Watching for SASS changes...');
+
+  // Watch for changes
+  watch(input, { delay: 250 }, sass);
+
+  // Complete
+  return complete();
+}
+
+// Default Task
+module.exports = series(sass, sassWatcher);

package/dist/gulp/tasks/serve.js

@@ -0,0 +1,179 @@
+// Libraries
+const path = require('path');
+const { watch, series } = require('gulp');
+const browserSync = require('browser-sync').create();
+const jetpack = require('fs-jetpack');
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('serve');
+
+// Local URL
+let localUrl;
+let externalUrl;
+
+// BrowserSync settings
+const settings = {
+  port: 4000,
+  browser: 'default',
+  cors: true,
+  open: 'external',
+  ghostMode: false,
+  server: {
+    baseDir: '_site',
+    middleware: async function (req, res, next) {
+      const url = new URL(`${localUrl}${req.url}`);
+      const pathname = url.pathname;
+
+      // Set the query object
+      req.query = {};
+      req.body = {};
+
+      // If the file has no ext, log it
+      if (!path.extname(pathname)) {
+        logger.log(`Serving ${pathname}`);
+      }
+
+      // Process the post request
+      if (pathname.match(/\/_process/)) {
+        const qsUrl = url.searchParams.get('url');
+        let lib;
+
+        // Set query
+        url.searchParams.forEach((value, key) => {
+          req.query[key] = value;
+        })
+
+        // Set body
+        if (req.method === 'POST') {
+          req.body = await receiveRequestBody(req);
+        }
+
+        // Try to load the library
+        try {
+          // Clear the cache
+          delete require.cache[require.resolve(`../${qsUrl}`)];
+
+          // Load the library
+          lib = require(`../${qsUrl}`);
+        } catch (e) {
+          // Log the error
+          logger.error(`Error processing ${qsUrl}`);
+
+          // Set the status code
+          res.statusCode = 500;
+
+          // Return an error
+          return res.write(`Cannot find ${qsUrl}`);
+        }
+
+        // Log
+        logger.log(`Processing ${qsUrl}`);
+
+        // Process the library
+        return await lib({
+          req: req,
+          res: res,
+        })
+        .then((r) => {
+          // Set the status code
+          res.statusCode = 200;
+
+          // Write the response (if it's JSON, set the content type)
+          try {
+            r = JSON.stringify(r);
+            res.setHeader('Content-Type', 'application/json');
+          } catch (e) {
+          }
+
+          // End the response
+          res.write(r);
+          res.end();
+        })
+        .catch((e) => {
+          // Set the status code
+          res.statusCode = 500;
+
+          // Write the error
+          res.write(`Error processing ${qsUrl}: ${e}`);
+          res.end();
+        });
+      }
+
+      // Check if the URL is missing a trailing slash and does not have an extension
+      if (!pathname.endsWith('/') && !path.extname(pathname)) {
+        // Get the new URL
+        const newURL = `${pathname}.html`;
+
+        // Log
+        // logger.log(`Rewriting ${pathname} to ${newURL}`);
+
+        // Rewrite it to serve the .html extension
+        req.url = newURL;
+      }
+
+      // Special case: Rewrite /blog/ to blog.html since Jekyll fucks it up locally
+      if (pathname === '/blog/') {
+        req.url = '/blog.html';
+      }
+
+      // Continue
+      return next();
+    },
+  },
+}
+
+// Task
+module.exports = function serve(complete) {
+  // Log
+  logger.log('Starting server setup...');
+
+  // Initialize browserSync
+  browserSync.init(settings, async (e, instance) => {
+    if (e) {
+      return logger.error(e);
+    }
+
+    // Get URLs
+    localUrl = instance.options.get('urls').get('local');
+    externalUrl = instance.options.get('urls').get('external');
+
+    // Write the config file
+    jetpack.write('.temp/_config_browsersync.yml', `url: ${externalUrl}`);
+
+    // Set global variable to access browserSync in other files
+    global.browserSync = browserSync;
+
+    // Log
+    logger.log('Finished server setup!');
+
+    // Complete
+    return complete();
+  });
+};
+
+function receiveRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = [];
+
+    // Listen for data
+    req.on('data', (chunk) => {
+      body.push(chunk.toString());
+    });
+
+    // Listen for errors
+    req.on('error', (err) => {
+      return reject(err);
+    });
+
+    // Listen for the end of the request
+    req.on('end', () => {
+      body = body.join('');
+
+      // Attempt to parse the body as JSON
+      try {
+        return resolve(JSON.parse(body));
+      } catch (e) {
+        return resolve(body);
+      }
+    });
+  });
+}

package/dist/gulp/tasks/test.js

@@ -0,0 +1,12 @@
+// Libraries
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('test');
+
+// Task
+module.exports = function test(complete) {
+  // Log
+  console.log('Starting test...');
+
+  // Complete
+  return complete();
+}

package/dist/gulp/tasks/webpack.js

@@ -0,0 +1,77 @@
+// Libraries
+const path = require('path');
+const wp = require('webpack');
+const Manager = new (require('../../index.js'));
+const logger = Manager.logger('webpack');
+
+// console.log('======', path.resolve(__dirname, 'node_modules', 'babel-loader', 'lib', 'index.js'));
+
+// Settings
+const MINIFY = false;
+const settings = {
+  mode: 'production',
+  entry: {
+    // default: './src/js/default.js', // Common scripts
+    default: './site/assets/js/test.js', // Common scripts
+    // pricing: './src/js/pricing.js', // Page-specific script
+    // about: './src/js/about.js'
+  },
+  output: {
+    filename: '[name].bundle.js',
+    // path: path.resolve(process.cwd(), 'site/assets/js'),
+    path: path.resolve(process.cwd(), 'site/compiled/js'),
+  },
+  resolveLoader: {
+    modules: [
+      path.resolve(process.cwd(), 'node_modules', 'ultimate-jekyll-manager', 'node_modules'), // Path to your helper module's node_modules
+      path.resolve(process.cwd(), 'node_modules'), // Default project node_modules
+      'node_modules', // Fallback to global
+    ]
+  },
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            // presets: ['@babel/preset-env'],
+            presets: [
+              require.resolve('@babel/preset-env', {
+                paths: [path.resolve(process.cwd(), 'node_modules', 'ultimate-jekyll-manager', 'node_modules')]
+              })
+            ],
+            compact: MINIFY,
+          }
+        }
+      }
+    ]
+  },
+  optimization: {
+    minimize: MINIFY,
+  },
+  watch: process.env.UJ_BUILD_MODE !== 'true',
+}
+
+// Task
+module.exports = function webpack(complete) {
+  // Log
+  logger.log('Starting webpack compilation...');
+
+  // Compiler
+  const compiler = wp(settings, (e, stats) => {
+    // Log
+    logger.log('Finished webpack compilation!');
+
+    // Error
+    if (e) {
+      logger.error(e);
+    } else {
+      logger.log('Stats:\n', stats.toString({ colors: true }));
+    }
+
+    // Complete
+    return complete(e);
+  });
+}

package/dist/index.js

@@ -0,0 +1,33 @@
+// Class
+function Manager() {
+  const self = this;
+
+  // Properties
+  self._logger = null;
+
+  // Return
+  return self;
+}
+
+// Initialize
+Manager.prototype.initialize = function () {
+  console.log('initialize:');
+};
+
+// Initialize
+Manager.prototype.logger = function (name) {
+  // Create logger
+  if (!this._logger) {
+    this._logger = new (require('./lib/logger'))(name);
+  }
+
+  return this._logger;
+};
+
+// Require
+Manager.require = function (path) {
+  return require(path);
+};
+
+// Export
+module.exports = Manager;

package/dist/lib/logger.js

@@ -0,0 +1,56 @@
+// Libraries
+const chalk = require('chalk');
+
+// Logger class
+function Logger(name) {
+  const self = this;
+
+  // Properties
+  self.name = name;
+}
+
+// Loop through log, error, warn, and info and make methods that log to console with the name and time [xx:xx:xx] name: message
+['log', 'error', 'warn', 'info'].forEach((method) => {
+  Logger.prototype[method] = function () {
+    // Get time
+    const time = new Date().toLocaleTimeString('en-US', {
+      hour12: false,
+      hour: '2-digit',
+      minute: '2-digit',
+      second: '2-digit'
+    });
+
+    // Determine color based on method
+    let color;
+    switch (method) {
+      case 'warn':
+        color = chalk.yellow;
+        break;
+      case 'error':
+        color = chalk.red;
+        break;
+      default:
+        color = (text) => text; // No color
+    }
+
+    // Convert arguments to array and prepend time and name
+    const args = [`[${chalk.magenta(time)}] '${chalk.cyan(this.name)}':`, ...Array.from(arguments).map(arg => {
+      return typeof arg === 'string'
+        ? color(arg)
+        : (
+            arg instanceof Error
+              ? color(arg.stack)
+              : arg
+          );
+    })];
+
+    // Log
+    console[method].apply(console, args);
+  };
+});
+
+// Export chalk as color
+Logger.prototype.format = chalk;
+
+// Export
+module.exports = Logger;