@abreen/tada 1.0.2 → 1.1.0

package/webpack/config.base.js

@@ -1,151 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const _ = require('lodash');
-const CopyPlugin = require('copy-webpack-plugin');
-const MiniCssExtractPlugin = require('mini-css-extract-plugin');
-const GenerateContentAssetsPlugin = require('./generate-content-assets-plugin');
-const PagefindPlugin = require('./pagefind-plugin');
-const GenerateFaviconPlugin = require('./generate-favicon-plugin');
-const GenerateManifestPlugin = require('./generate-manifest-plugin');
-const GenerateFontsPlugin = require('./generate-fonts-plugin');
-const { getDistDir, createDefinePlugin } = require('./util');
-const { isFeatureEnabled } = require('./features');
-const {
-  getContentDir,
-  getPackageDir,
-  getProjectDir,
-  getPublicDir,
-} = require('./utils/paths');
-const { parseHsl } = require('./utils/parse-hsl');
-
-const distDir = getDistDir();
-
-function renderThemeScss(siteVariables) {
-  const templatePath = path.join(getPackageDir(), 'templates/_theme.scss');
-  const template = fs.readFileSync(templatePath, 'utf-8');
-  const { hue, saturation, lightness } = parseHsl(siteVariables.themeColor);
-  const tintHue = siteVariables.tintHue ?? 20;
-  const tintAmount = siteVariables.tintAmount ?? 100;
-  const rendered = _.template(template)({
-    themeHue: hue,
-    themeSaturation: saturation,
-    themeLightness: lightness,
-    tintHue,
-    tintAmount,
-  });
-
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-'));
-  const configDir = path.join(tmpDir, 'config');
-  fs.mkdirSync(configDir);
-  fs.writeFileSync(path.join(configDir, '_theme.scss'), rendered);
-
-  return tmpDir;
-}
-
-function createModuleRules(siteVariables) {
-  const packageDir = getPackageDir();
-  const themeDir = renderThemeScss(siteVariables);
-
-  return [
-    { test: /\.js$/, exclude: /node_modules/, use: { loader: 'babel-loader' } },
-    {
-      test: /\.tsx?$/,
-      include: path.resolve(packageDir, 'src'),
-      loader: 'ts-loader',
-      options: { configFile: path.resolve(packageDir, 'tsconfig.json') },
-    },
-    {
-      test: /\.(sa|sc|c)ss$/,
-      use: [
-        MiniCssExtractPlugin.loader,
-        {
-          loader: 'css-loader',
-          options: {
-            url: {
-              // Don't bundle fonts (they are handled by GenerateFontsPlugin)
-              filter: url => !url.endsWith('.woff2'),
-            },
-          },
-        },
-        {
-          loader: 'sass-loader',
-          options: { sassOptions: { loadPaths: [themeDir, getProjectDir()] } },
-        },
-      ],
-    },
-  ];
-}
-
-async function createPlugins(
-  siteVariables,
-  { defineIsDev = false, plugins = [] } = {},
-) {
-  return [
-    new GenerateContentAssetsPlugin(siteVariables),
-    createDefinePlugin(siteVariables, defineIsDev),
-    new MiniCssExtractPlugin({
-      filename: '[name].css',
-      chunkFilename: '[id].css',
-    }),
-    new CopyPlugin({
-      patterns: [
-        { from: getPublicDir(), to: '.', noErrorOnMissing: true },
-        {
-          from: '**/*.{png,jpg,jpeg,gif,svg,txt,zip}',
-          context: getContentDir(),
-          to: '[path][name][ext]',
-          noErrorOnMissing: true,
-        },
-      ],
-    }),
-    isFeatureEnabled(siteVariables, 'search')
-      ? new PagefindPlugin(siteVariables)
-      : null,
-    isFeatureEnabled(siteVariables, 'favicon')
-      ? new GenerateFaviconPlugin(siteVariables)
-      : null,
-    isFeatureEnabled(siteVariables, 'favicon')
-      ? new GenerateManifestPlugin(siteVariables)
-      : null,
-    new GenerateFontsPlugin(),
-    ...plugins,
-    require('./print-flair-plugin'),
-  ].filter(Boolean);
-}
-
-async function createBaseConfig({
-  mode,
-  siteVariables,
-  entry,
-  devtool,
-  defineIsDev = false,
-  optimization,
-  plugins,
-}) {
-  const packageDir = getPackageDir();
-  return {
-    mode,
-    entry,
-    output: {
-      path: distDir,
-      publicPath: siteVariables.basePath,
-      filename: '[name].bundle.js',
-    },
-    resolve: { extensions: ['.ts', '.js', '.json'] },
-    resolveLoader: {
-      modules: [
-        path.resolve(packageDir, 'node_modules'),
-        path.resolve(packageDir, '..', '..'),
-        'node_modules',
-      ],
-    },
-    devtool,
-    module: { rules: createModuleRules(siteVariables) },
-    ...(optimization && { optimization }),
-    plugins: await createPlugins(siteVariables, { defineIsDev, plugins }),
-    stats: 'errors-only',
-  };
-}
-
-module.exports = { createBaseConfig };

package/webpack/config.dev.js

@@ -1,23 +0,0 @@
-const path = require('path');
-const ContentWatchPlugin = require('./content-watch-plugin');
-const { createBaseConfig } = require('./config.base');
-const { getDevSiteVariables } = require('./site-variables');
-const { getPackageDir } = require('./utils/paths');
-
-module.exports = async (env = {}) => {
-  const siteVariables = getDevSiteVariables();
-  const packageDir = getPackageDir();
-  const entry = { index: path.resolve(packageDir, 'src/index.ts') };
-  if (env.watchMode) {
-    entry.reload = path.resolve(packageDir, 'webpack/watch-reload-client.js');
-  }
-
-  return createBaseConfig({
-    mode: 'development',
-    devtool: 'inline-source-map',
-    siteVariables,
-    entry,
-    defineIsDev: true,
-    plugins: [new ContentWatchPlugin(siteVariables)],
-  });
-};

package/webpack/config.prod.js

@@ -1,32 +0,0 @@
-const path = require('path');
-const TerserPlugin = require('terser-webpack-plugin');
-const { createBaseConfig } = require('./config.base');
-const { compileTemplates } = require('./templates');
-const { getProdSiteVariables } = require('./site-variables');
-const { getPackageDir } = require('./utils/paths');
-
-const siteVariables = getProdSiteVariables();
-
-module.exports = async () => {
-  compileTemplates(siteVariables);
-
-  return createBaseConfig({
-    mode: 'production',
-    siteVariables,
-    entry: { index: path.resolve(getPackageDir(), 'src/index.ts') },
-    devtool: false,
-    optimization: {
-      minimizer: [
-        /*
-         * Bun's event loop doesn't track TerserPlugin's worker threads,
-         * causing a premature exit; set parallel to false to prevent worker
-         * threads from being used.
-         */
-        new TerserPlugin({
-          parallel: false,
-          terserOptions: { output: { comments: false } },
-        }),
-      ],
-    },
-  });
-};

package/webpack/content-watch-plugin.js

@@ -1,153 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const {
-  getContentDir,
-  getContentFiles,
-  getBuildContentFiles,
-} = require('./util');
-const { setWatchState } = require('./build-state');
-const {
-  compileTemplates,
-  getHtmlTemplatesDir,
-  getJsonDataDir,
-  JSON_DATA_FILES,
-} = require('./templates');
-const { getProjectDir } = require('./utils/paths');
-
-let _needsRestart = false;
-
-class ContentWatchPlugin {
-  constructor(siteVariables) {
-    this.siteVariables = siteVariables;
-    this.siteConfigPath = path.resolve(
-      getProjectDir(),
-      'config',
-      'site.dev.json',
-    );
-  }
-
-  apply(compiler) {
-    let lastSig = null;
-
-    compiler.hooks.make.tap('ContentWatchPlugin', compilation => {
-      const htmlTemplatesDir = getHtmlTemplatesDir();
-      const jsonDataDir = getJsonDataDir();
-
-      // Refresh templates cache from disk
-      try {
-        compileTemplates(this.siteVariables);
-      } catch (err) {
-        compilation.errors.push(err);
-        for (const fileName of fs.readdirSync(htmlTemplatesDir)) {
-          compilation.fileDependencies.add(
-            path.join(htmlTemplatesDir, fileName),
-          );
-        }
-        for (const dataFile of JSON_DATA_FILES) {
-          const dataPath = path.join(jsonDataDir, dataFile);
-          if (fs.existsSync(dataPath)) {
-            compilation.fileDependencies.add(dataPath);
-          }
-        }
-        return;
-      }
-
-      const contentDir = getContentDir();
-      const modifiedFiles = new Set(
-        [...(compiler.modifiedFiles || [])].map(filePath =>
-          path.resolve(filePath),
-        ),
-      );
-      const normalizedContentDir = path.resolve(contentDir) + path.sep;
-      const normalizedHtmlDir = path.resolve(htmlTemplatesDir) + path.sep;
-      const contentFiles = getContentFiles(
-        contentDir,
-        Object.keys(this.siteVariables.codeLanguages),
-      );
-      const buildContentFiles = getBuildContentFiles(
-        contentDir,
-        Object.keys(this.siteVariables.codeLanguages),
-      );
-
-      // Detect structural changes (files added or deleted) that require a
-      // fresh compiler with updated content asset caches
-      const sig = buildContentFiles.slice().sort().join('\0');
-      let structureChanged = false;
-      if (lastSig !== null && sig !== lastSig) {
-        _needsRestart = true;
-        structureChanged = true;
-      }
-      lastSig = sig;
-
-      const changedContentFiles = new Set(
-        [...modifiedFiles].filter(filePath =>
-          filePath.startsWith(normalizedContentDir),
-        ),
-      );
-
-      // Check if any HTML template or JSON data file changed
-      const jsonDataPaths = JSON_DATA_FILES.map(f =>
-        path.resolve(jsonDataDir, f),
-      );
-      const templatesChanged = [...modifiedFiles].some(
-        filePath =>
-          filePath === path.resolve(htmlTemplatesDir) ||
-          filePath.startsWith(normalizedHtmlDir) ||
-          jsonDataPaths.includes(filePath),
-      );
-
-      setWatchState(compiler, {
-        contentFiles,
-        buildContentFiles,
-        changedContentFiles,
-        templatesChanged,
-        structureChanged,
-      });
-
-      // Tell webpack to watch all content files
-      for (const filePath of contentFiles) {
-        compilation.fileDependencies.add(filePath);
-      }
-
-      // Watch content directories so webpack detects newly added files
-      function addDirs(dir) {
-        compilation.contextDependencies.add(dir);
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-          if (entry.isDirectory()) {
-            addDirs(path.join(dir, entry.name));
-          }
-        }
-      }
-      addDirs(contentDir);
-
-      // Watch HTML template files from the package
-      for (const fileName of fs.readdirSync(htmlTemplatesDir)) {
-        compilation.fileDependencies.add(path.join(htmlTemplatesDir, fileName));
-      }
-
-      // Watch JSON data files from the project config
-      for (const dataFile of JSON_DATA_FILES) {
-        const dataPath = path.join(jsonDataDir, dataFile);
-        if (fs.existsSync(dataPath)) {
-          compilation.fileDependencies.add(dataPath);
-        }
-      }
-
-      // Watch the site config file and restart when it changes
-      compilation.fileDependencies.add(this.siteConfigPath);
-      const siteConfigChanged = modifiedFiles.has(
-        path.resolve(this.siteConfigPath),
-      );
-      if (siteConfigChanged) {
-        _needsRestart = true;
-      }
-    });
-  }
-}
-
-ContentWatchPlugin.needsRestart = () => _needsRestart;
-ContentWatchPlugin.clearRestart = () => {
-  _needsRestart = false;
-};
-
-module.exports = ContentWatchPlugin;

package/webpack/features.js

@@ -1,5 +0,0 @@
-function isFeatureEnabled(siteVariables, featureName) {
-  return siteVariables.features?.[featureName] !== false;
-}
-
-module.exports = { isFeatureEnabled };

package/webpack/generate-content-assets-plugin.js

@@ -1,308 +0,0 @@
-const path = require('path');
-const { RawSource } = require('webpack').sources;
-const { makeLogger } = require('./log');
-const { isFeatureEnabled } = require('./features');
-const { initHighlighter } = require('./utils/shiki-highlighter');
-const {
-  getBuildContentFiles,
-  getContentDir,
-  getValidInternalTargets,
-  renderCodePageAsset,
-  renderCopiedContentAsset,
-  renderLiterateJavaPageAsset,
-  renderPlainTextPageAsset,
-} = require('./util');
-const { isLiterateJava } = require('./utils/file-types');
-const { getWatchState, setBuildDelta } = require('./build-state');
-
-const log = makeLogger(__filename);
-
-function normalizePaths(paths) {
-  return [...paths];
-}
-
-class GenerateContentAssetsPlugin {
-  constructor(siteVariables) {
-    this.siteVariables = siteVariables || {};
-    this.loggedCodeDisabled = false;
-    this.sourceFileCache = new Map();
-    this.lastBuildFiles = new Set();
-  }
-
-  getBuildContentFiles(compiler) {
-    const watchState = getWatchState(compiler);
-    if (watchState?.buildContentFiles?.size) {
-      return normalizePaths(watchState.buildContentFiles);
-    }
-
-    return getBuildContentFiles(
-      getContentDir(),
-      Object.keys(this.siteVariables.codeLanguages || {}),
-    );
-  }
-
-  getDirtySourceFiles(compiler, buildContentFiles) {
-    const watchState = getWatchState(compiler);
-    const isWatch = !!compiler.watching;
-
-    if (
-      !isWatch ||
-      this.lastBuildFiles.size === 0 ||
-      !watchState ||
-      watchState.templatesChanged
-    ) {
-      return new Set(buildContentFiles);
-    }
-
-    const buildFileSet = new Set(buildContentFiles);
-    const dirtySourceFiles = new Set();
-    for (const filePath of watchState.changedContentFiles) {
-      if (buildFileSet.has(filePath)) {
-        dirtySourceFiles.add(filePath);
-      }
-    }
-    return dirtySourceFiles;
-  }
-
-  isCopiedAssetSource(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    const codeExtensions = this.siteVariables.codeLanguages || {};
-    return (
-      ext === '.pdf' ||
-      Object.prototype.hasOwnProperty.call(codeExtensions, ext.slice(1))
-    );
-  }
-
-  getDirtyCopiedSourceFiles(compiler, buildContentFiles) {
-    const watchState = getWatchState(compiler);
-    const isWatch = !!compiler.watching;
-
-    if (!isWatch || this.lastBuildFiles.size === 0 || !watchState) {
-      return buildContentFiles.filter(filePath =>
-        this.isCopiedAssetSource(filePath),
-      );
-    }
-
-    const buildFileSet = new Set(buildContentFiles);
-    const dirtyCopiedSourceFiles = [];
-    for (const filePath of watchState.changedContentFiles) {
-      if (!buildFileSet.has(filePath) || !this.isCopiedAssetSource(filePath)) {
-        continue;
-      }
-      dirtyCopiedSourceFiles.push(filePath);
-    }
-
-    return dirtyCopiedSourceFiles;
-  }
-
-  renderSourceAssets(filePath, contentDir, validInternalTargets, compilation) {
-    const ext = path.extname(filePath).toLowerCase();
-    const assets = [];
-
-    if (isLiterateJava(filePath)) {
-      if (isFeatureEnabled(this.siteVariables, 'literateJava')) {
-        assets.push(
-          ...renderLiterateJavaPageAsset({
-            filePath,
-            contentDir,
-            siteVariables: this.siteVariables,
-            compilation,
-          }),
-        );
-      }
-      return assets;
-    }
-
-    if (ext === '.html' || ext === '.md' || ext === '.markdown') {
-      assets.push(
-        ...renderPlainTextPageAsset({
-          filePath,
-          contentDir,
-          siteVariables: this.siteVariables,
-          validInternalTargets,
-          compilation,
-        }),
-      );
-      return assets;
-    }
-
-    if (ext === '.pdf') {
-      return assets;
-    }
-
-    const codeExtensions = this.siteVariables.codeLanguages || {};
-    if (ext.slice(1) in codeExtensions) {
-      if (isFeatureEnabled(this.siteVariables, 'code')) {
-        assets.push(
-          ...renderCodePageAsset({
-            filePath,
-            contentDir,
-            siteVariables: this.siteVariables,
-            compilation,
-          }),
-        );
-      } else if (!this.loggedCodeDisabled) {
-        log.info`Not generating source code pages due to site.features.code = false`;
-        this.loggedCodeDisabled = true;
-      }
-    }
-
-    return assets;
-  }
-
-  emitUncachedAssets(compilation, copiedSourceFiles, contentDir) {
-    for (const filePath of copiedSourceFiles) {
-      for (const asset of renderCopiedContentAsset({ filePath, contentDir })) {
-        const source = new RawSource(asset.content);
-        if (compilation.getAsset(asset.assetPath)) {
-          compilation.updateAsset(asset.assetPath, source);
-        } else {
-          compilation.emitAsset(asset.assetPath, source);
-        }
-      }
-    }
-  }
-
-  updateSourceCache(
-    filePath,
-    assets,
-    changedHtmlAssetPaths,
-    removedHtmlAssetPaths,
-  ) {
-    const previousAssets = this.sourceFileCache.get(filePath) || [];
-    const nextAssetPaths = new Set(assets.map(asset => asset.assetPath));
-
-    for (const asset of previousAssets) {
-      if (nextAssetPaths.has(asset.assetPath)) {
-        continue;
-      }
-      if (asset.assetPath.endsWith('.html')) {
-        removedHtmlAssetPaths.add(asset.assetPath);
-      }
-    }
-
-    for (const asset of assets) {
-      if (asset.assetPath.endsWith('.html')) {
-        changedHtmlAssetPaths.add(asset.assetPath);
-      }
-    }
-
-    this.sourceFileCache.set(filePath, assets);
-  }
-
-  emitCachedAssets(compilation, buildContentFiles) {
-    for (const filePath of buildContentFiles) {
-      const assets = this.sourceFileCache.get(filePath) || [];
-      for (const asset of assets) {
-        const source = new RawSource(asset.content);
-        if (compilation.getAsset(asset.assetPath)) {
-          compilation.updateAsset(asset.assetPath, source);
-        } else {
-          compilation.emitAsset(asset.assetPath, source);
-        }
-      }
-    }
-  }
-
-  pruneRemovedSources(buildFileSet, removedHtmlAssetPaths) {
-    for (const filePath of [...this.lastBuildFiles]) {
-      if (buildFileSet.has(filePath)) {
-        continue;
-      }
-
-      const previousAssets = this.sourceFileCache.get(filePath) || [];
-      for (const asset of previousAssets) {
-        if (asset.assetPath.endsWith('.html')) {
-          removedHtmlAssetPaths.add(asset.assetPath);
-        }
-      }
-      this.sourceFileCache.delete(filePath);
-    }
-  }
-
-  apply(compiler) {
-    const pluginName = 'GenerateContentAssetsPlugin';
-
-    compiler.hooks.beforeCompile.tapPromise(pluginName, async () => {
-      const langs = [
-        ...new Set([
-          'plaintext',
-          'text',
-          ...Object.values(this.siteVariables.codeLanguages || {}),
-        ]),
-      ];
-      await initHighlighter(langs);
-    });
-
-    compiler.hooks.thisCompilation.tap(pluginName, compilation => {
-      compilation.hooks.processAssets.tap(
-        {
-          name: pluginName,
-          stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
-        },
-        () => {
-          const contentDir = getContentDir();
-          const buildContentFiles = this.getBuildContentFiles(compiler);
-          log.info`Processing ${buildContentFiles.length} content file(s)`;
-          const buildFileSet = new Set(buildContentFiles);
-          const dirtySourceFiles = this.getDirtySourceFiles(
-            compiler,
-            buildContentFiles,
-          );
-          const dirtyCopiedSourceFiles = this.getDirtyCopiedSourceFiles(
-            compiler,
-            buildContentFiles,
-          );
-          const changedHtmlAssetPaths = new Set();
-          const removedHtmlAssetPaths = new Set();
-          const validInternalTargets = getValidInternalTargets(
-            contentDir,
-            buildContentFiles,
-            Object.keys(this.siteVariables.codeLanguages || {}),
-          );
-          const watchState = getWatchState(compiler);
-
-          this.pruneRemovedSources(buildFileSet, removedHtmlAssetPaths);
-
-          for (const filePath of dirtySourceFiles) {
-            let assets;
-            try {
-              assets = this.renderSourceAssets(
-                filePath,
-                contentDir,
-                validInternalTargets,
-                compilation,
-              );
-            } catch (err) {
-              compilation.errors.push(err);
-              continue;
-            }
-            this.updateSourceCache(
-              filePath,
-              assets,
-              changedHtmlAssetPaths,
-              removedHtmlAssetPaths,
-            );
-          }
-
-          this.emitCachedAssets(compilation, buildContentFiles);
-          this.emitUncachedAssets(
-            compilation,
-            dirtyCopiedSourceFiles,
-            contentDir,
-          );
-          this.lastBuildFiles = buildFileSet;
-
-          setBuildDelta(compiler, {
-            changedSourceFiles: dirtySourceFiles,
-            changedHtmlAssetPaths,
-            removedHtmlAssetPaths,
-            templatesChanged: Boolean(watchState?.templatesChanged),
-          });
-        },
-      );
-    });
-  }
-}
-
-module.exports = GenerateContentAssetsPlugin;