@rustwrap/webpack 1.0.1

package/lib/plugins.js

@@ -0,0 +1,130 @@
+"use strict";
+/*
+ * Built-in webpack plugins. Bundler-affecting plugins (Define/Provide/Environment/Ignore/
+ * NormalModuleReplacement) populate `compiler.$rollpack`, which build.js reads during the Rolldown
+ * make phase. Asset-affecting plugins (Banner) tap compilation.processAssets. The rest are faithful
+ * no-ops or thin shims so configs load and run.
+ */
+const { STAGES } = require("./compiler");
+
+function flattenDefinitions(defs, prefix, out) {
+  for (const [k, v] of Object.entries(defs || {})) {
+    const key = prefix ? `${prefix}.${k}` : k;
+    if (v && typeof v === "object" && !(v instanceof RegExp) && !Array.isArray(v)) flattenDefinitions(v, key, out);
+    else out[key] = typeof v === "string" ? v : (v instanceof RegExp ? v.toString() : JSON.stringify(v));
+  }
+  return out;
+}
+
+class DefinePlugin {
+  constructor(definitions) { this.definitions = definitions || {}; }
+  apply(compiler) { Object.assign(compiler.$rollpack.define, flattenDefinitions(this.definitions, "", {})); }
+}
+DefinePlugin.runtimeValue = (fn, deps) => { const v = fn({}); return typeof v === "string" ? v : JSON.stringify(v); };
+
+class EnvironmentPlugin {
+  constructor(...keys) { this.keys = Array.isArray(keys[0]) ? keys[0] : (typeof keys[0] === "object" ? keys[0] : keys); }
+  apply(compiler) {
+    const d = compiler.$rollpack.define;
+    if (Array.isArray(this.keys)) for (const k of this.keys) d[`process.env.${k}`] = JSON.stringify(process.env[k] !== undefined ? process.env[k] : "");
+    else for (const [k, def] of Object.entries(this.keys)) d[`process.env.${k}`] = JSON.stringify(process.env[k] !== undefined ? process.env[k] : def);
+  }
+}
+
+class ProvidePlugin {
+  constructor(definitions) { this.definitions = definitions || {}; }
+  apply(compiler) { Object.assign(compiler.$rollpack.provide, this.definitions); }
+}
+
+class BannerPlugin {
+  constructor(options) { this.options = typeof options === "string" ? { banner: options } : (options || {}); }
+  apply(compiler) {
+    const o = this.options;
+    const text = typeof o.banner === "function" ? o.banner : o.banner || "";
+    const make = (filename) => {
+      const raw = typeof text === "function" ? text({ filename }) : text;
+      if (o.raw) return raw;
+      return "/*! " + String(raw).replace(/\*\//g, "*\\/") + " */\n";
+    };
+    const test = o.test, include = o.include, exclude = o.exclude;
+    const matches = (name) => {
+      const m = (c, v) => c == null ? true : (c instanceof RegExp ? c.test(v) : (typeof c === "string" ? v.includes(c) : true));
+      if (!m(test, name)) return false;
+      if (include != null && !m(include, name)) return false;
+      if (exclude != null && m(exclude, name) && exclude != null) return false;
+      return /\.(js|mjs|cjs)$/.test(name) || test != null;
+    };
+    compiler.hooks.compilation.tap("BannerPlugin", (compilation) => {
+      compilation.hooks.processAssets.tap({ name: "BannerPlugin", stage: STAGES.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE }, (assets) => {
+        for (const name of Object.keys(assets)) {
+          if (!matches(name)) continue;
+          const src = assets[name];
+          const cur = src.source();
+          compilation.updateAsset(name, make(name) + (Buffer.isBuffer(cur) ? cur.toString("utf8") : cur));
+        }
+      });
+    });
+  }
+}
+
+class IgnorePlugin {
+  constructor(options) { this.options = (options && options.resourceRegExp) ? options : { resourceRegExp: options && options.checkResource ? undefined : options, checkResource: options && options.checkResource }; }
+  apply(compiler) { compiler.$rollpack.ignore.push(this.options); }
+}
+
+class NormalModuleReplacementPlugin {
+  constructor(resourceRegExp, newResource) { this.resourceRegExp = resourceRegExp; this.newResource = newResource; }
+  apply(compiler) { compiler.$rollpack.normalReplace.push([this.resourceRegExp, this.newResource]); }
+}
+
+class ContextReplacementPlugin {
+  constructor(resourceRegExp, newContentResource) { this.resourceRegExp = resourceRegExp; this.newContentResource = newContentResource; }
+  apply() {}
+}
+
+class SourceMapDevToolPlugin {
+  constructor(options) { this.options = options || {}; }
+  apply(compiler) { if (!compiler.options.devtool) compiler.options.devtool = this.options.inline ? "inline-source-map" : "source-map"; }
+}
+class EvalSourceMapDevToolPlugin {
+  constructor(options) { this.options = options || {}; }
+  apply(compiler) { if (!compiler.options.devtool) compiler.options.devtool = "inline-source-map"; }
+}
+
+class ProgressPlugin {
+  constructor(handler) { this.handler = typeof handler === "function" ? handler : (handler && handler.handler); }
+  apply(compiler) {
+    if (!this.handler) return;
+    compiler.hooks.run.tapPromise("ProgressPlugin", async () => { try { this.handler(0, "compiling"); } catch (_) {} });
+    compiler.hooks.done.tapPromise("ProgressPlugin", async () => { try { this.handler(1, "done"); } catch (_) {} });
+  }
+}
+
+// Faithful no-ops (single-file output / behaviors already covered by Rolldown).
+class NoopPlugin { constructor(options) { this.options = options; } apply() {} }
+class LimitChunkCountPlugin extends NoopPlugin {}
+class MinChunkSizePlugin extends NoopPlugin {}
+class AggressiveMergingPlugin extends NoopPlugin {}
+class ModuleConcatenationPlugin extends NoopPlugin {}
+class RuntimeChunkPlugin extends NoopPlugin {}
+class SplitChunksPlugin extends NoopPlugin {}
+class WatchIgnorePlugin extends NoopPlugin {}
+class LoaderOptionsPlugin extends NoopPlugin {}
+class HotModuleReplacementPlugin { apply(compiler) { compiler.$rollpack = compiler.$rollpack || {}; compiler.$rollpack.hot = true; } }
+class DllPlugin extends NoopPlugin {}
+class DllReferencePlugin extends NoopPlugin {}
+class HashedModuleIdsPlugin extends NoopPlugin {}
+class NamedModulesPlugin extends NoopPlugin {}
+class NamedChunksPlugin extends NoopPlugin {}
+class NoEmitOnErrorsPlugin extends NoopPlugin {}
+class ModuleFederationPlugin extends NoopPlugin {}
+
+module.exports = {
+  DefinePlugin, EnvironmentPlugin, ProvidePlugin, BannerPlugin, IgnorePlugin,
+  NormalModuleReplacementPlugin, ContextReplacementPlugin, SourceMapDevToolPlugin,
+  EvalSourceMapDevToolPlugin, ProgressPlugin, LoaderOptionsPlugin, HotModuleReplacementPlugin,
+  WatchIgnorePlugin, DllPlugin, DllReferencePlugin, HashedModuleIdsPlugin, NamedModulesPlugin,
+  NamedChunksPlugin, NoEmitOnErrorsPlugin,
+  optimize: { LimitChunkCountPlugin, MinChunkSizePlugin, AggressiveMergingPlugin, ModuleConcatenationPlugin, RuntimeChunkPlugin, SplitChunksPlugin },
+  container: { ModuleFederationPlugin },
+};

package/lib/sourcemap.js

@@ -0,0 +1,13 @@
+"use strict";
+/* webpack `devtool` -> Rolldown output.sourcemap option. */
+function devtoolToRolldown(devtool) {
+  if (!devtool || devtool === "false" || devtool === false || devtool === "none") return { sourcemap: false, excludeSources: false };
+  const d = String(devtool);
+  let sourcemap = true;
+  if (d.includes("inline")) sourcemap = "inline";
+  else if (d.includes("hidden")) sourcemap = "hidden";
+  // eval-* variants aren't supported by Rolldown; approximate with inline maps.
+  else if (d.includes("eval")) sourcemap = "inline";
+  return { sourcemap, excludeSources: d.includes("nosources") };
+}
+module.exports = { devtoolToRolldown };

package/lib/stats.js

@@ -0,0 +1,60 @@
+"use strict";
+/* webpack-compatible Stats built from a Compilation's assets/errors/warnings. */
+
+function createStats(compilation) {
+  const errors = compilation.errors || [];
+  const warnings = compilation.warnings || [];
+  const time = compilation.__time || 0;
+  const assetList = Object.keys(compilation.assets).map((name) => {
+    const src = compilation.assets[name];
+    const content = src.source();
+    return { name, size: Buffer.isBuffer(content) ? content.length : Buffer.byteLength(String(content), "utf8"), info: compilation.assetsInfo.get(name) || {}, chunks: [], chunkNames: [], emitted: true };
+  });
+  const normErr = (e) => (e && typeof e === "object") ? { message: e.message || String(e), stack: e.stack, moduleName: e.moduleName } : { message: String(e) };
+
+  const stats = {
+    compilation,
+    startTime: compilation.__startTime || 0,
+    endTime: (compilation.__startTime || 0) + time,
+    hasErrors: () => errors.length > 0,
+    hasWarnings: () => warnings.length > 0,
+    toJson(opts) {
+      return {
+        version: require("../package.json").version,
+        rollpack: true,
+        hash: compilation.hash || "",
+        time,
+        builtAt: Date.now(),
+        publicPath: (compilation.outputOptions && compilation.outputOptions.publicPath) || "",
+        outputPath: compilation.compiler.outputPath,
+        assetsByChunkName: {},
+        assets: assetList,
+        chunks: [],
+        modules: [],
+        entrypoints: {},
+        namedChunkGroups: {},
+        errors: errors.map(normErr),
+        warnings: warnings.map(normErr),
+        errorsCount: errors.length,
+        warningsCount: warnings.length,
+        children: [],
+      };
+    },
+    toString(opts) {
+      const useColors = opts && (opts === true || opts.colors);
+      const C = useColors ? { d: "\x1b[2m", g: "\x1b[32m", c: "\x1b[36m", y: "\x1b[33m", r: "\x1b[0m" } : { d: "", g: "", c: "", y: "", r: "" };
+      const lines = [];
+      for (const e of errors) lines.push(`${C.y}ERROR${C.r} ` + (e.message || String(e)));
+      for (const w of warnings) lines.push(`${C.y}WARNING${C.r} ` + (w.message || String(w)));
+      const total = assetList.reduce((s, a) => s + a.size, 0);
+      lines.push(`${C.c}rollpack${C.r} ${C.g}${assetList.length} assets${C.r} ${C.d}${fmt(total)} in ${time}ms${C.r}`);
+      for (const a of assetList) lines.push(`  ${C.d}asset${C.r} ${C.c}${a.name}${C.r}  ${fmt(a.size)}`);
+      return lines.join("\n");
+    },
+  };
+  return stats;
+}
+
+function fmt(b) { return b > 1048576 ? (b / 1048576).toFixed(2) + " MiB" : (b / 1024).toFixed(1) + " KiB"; }
+
+module.exports = { createStats };

package/lib/template.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const crypto = require('crypto');
+const path = require('path');
+
+const DEFAULT_HASH_LENGTH = 20;
+
+function hasValue(value) {
+  return value !== undefined && value !== null;
+}
+
+function asString(value) {
+  return hasValue(value) ? String(value) : '';
+}
+
+function normalizeLength(len) {
+  if (!hasValue(len)) {
+    return DEFAULT_HASH_LENGTH;
+  }
+
+  const parsed = Number(len);
+  return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_HASH_LENGTH;
+}
+
+function getHash(content, len) {
+  const length = normalizeLength(len);
+  const input = hasValue(content) ? content : '';
+  const algorithm = crypto.getHashes().includes('md4') ? 'md4' : 'sha256';
+
+  try {
+    return crypto.createHash(algorithm).update(input).digest('hex').slice(0, length);
+  } catch (error) {
+    // Some OpenSSL builds list md4 but still reject it at runtime.
+    return crypto.createHash('sha256').update(input).digest('hex').slice(0, length);
+  }
+}
+
+function basename(resourcePath) {
+  if (!hasValue(resourcePath)) {
+    return '';
+  }
+
+  return path.win32.basename(path.posix.basename(String(resourcePath)));
+}
+
+function derivedExt(vars) {
+  if (hasValue(vars.ext)) {
+    return String(vars.ext);
+  }
+
+  const base = basename(vars.resourcePath);
+  return base ? path.extname(base) : '';
+}
+
+function derivedName(vars) {
+  if (hasValue(vars.name)) {
+    return String(vars.name);
+  }
+
+  const base = basename(vars.resourcePath);
+  const ext = base ? path.extname(base) : '';
+  return ext ? base.slice(0, -ext.length) : base;
+}
+
+function derivedBase(vars) {
+  const base = basename(vars.resourcePath);
+  if (base) {
+    return base;
+  }
+
+  const name = derivedName(vars);
+  const ext = derivedExt(vars);
+  return name || ext ? name + ext : '';
+}
+
+function relativePath(vars) {
+  if (!hasValue(vars.resourcePath) || !hasValue(vars.context)) {
+    return '';
+  }
+
+  const resourcePath = String(vars.resourcePath);
+  const context = String(vars.context);
+  const directory = path.dirname(resourcePath);
+
+  if (!directory || directory === '.') {
+    return '';
+  }
+
+  const relative = path.relative(context, directory);
+  if (!relative || relative === '.') {
+    return '';
+  }
+
+  return relative.replace(/\\/g, '/') + '/';
+}
+
+function hashValue(providedHash, content, len) {
+  const length = normalizeLength(len);
+  if (hasValue(providedHash)) {
+    return String(providedHash).slice(0, length);
+  }
+
+  return getHash(content, length);
+}
+
+function interpolateName(template, vars) {
+  const values = vars || {};
+
+  if (typeof template === 'function') {
+    return asString(template(values));
+  }
+
+  return asString(template).replace(/\[([A-Za-z]+)(?::(\d+))?\]/g, (match, token, len) => {
+    switch (token.toLowerCase()) {
+      case 'name':
+        return derivedName(values);
+      case 'ext':
+        return derivedExt(values);
+      case 'base':
+        return derivedBase(values);
+      case 'path':
+        return relativePath(values);
+      case 'query':
+        return asString(values.query);
+      case 'id':
+        return asString(hasValue(values.id) ? values.id : (hasValue(values.chunkName) ? values.chunkName : values.name));
+      case 'chunkname':
+        return asString(values.chunkName || values.name);
+      case 'hash':
+      case 'fullhash':
+        return hashValue(values.fullHash, values.content, len);
+      case 'contenthash':
+      case 'chunkhash':
+        return hashValue(values.contentHash, values.content, len);
+      default:
+        return match;
+    }
+  });
+}
+
+module.exports = {
+  interpolateName,
+  getHash,
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@rustwrap/webpack",
+  "version": "1.0.1",
+  "description": "A webpack-compatible Node API and CLI backed by the Rolldown bundler (Rust/Oxc) for fast builds and excellent tree-shaking. Drop-in `webpack` override for pcf-scripts and webpack-based pipelines.",
+  "main": "lib/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "bin": {
+    "webpack": "bin/rollpack.js",
+    "rollpack": "bin/rollpack.js"
+  },
+  "files": [
+    "lib/",
+    "bin/",
+    "README.md"
+  ],
+  "dependencies": {
+    "acorn": "^8.17.0",
+    "eslint-scope": "^9.1.2",
+    "loader-runner": "^4.3.2",
+    "mime-types": "^3.0.2",
+    "postcss": "^8.5.16",
+    "postcss-modules": "^6.0.1",
+    "rolldown": "^1.1.3",
+    "schema-utils": "^4.3.3",
+    "tapable": "^2.3.3",
+    "terser-webpack-plugin": "^5.6.1",
+    "webpack-sources": "^3.5.0"
+  },
+  "keywords": [
+    "webpack",
+    "rolldown",
+    "bundler",
+    "pcf",
+    "tree-shaking"
+  ],
+  "license": "MIT"
+}