anypack-plugin-serve 0.1.0-alpha.1

package/lib/plugins/ramdisk_lib.js

@@ -0,0 +1,146 @@
+/*
+  Copyright © 2019 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const fs = require('node:fs');
+const childProcess = require('node:child_process');
+
+const colors = require('ansi-colors');
+
+const defaults = {
+  blockSize: 512,
+  // 256 mb
+  bytes: 2.56e8,
+  name: 'wpr',
+};
+const name = 'WebpackPluginRamdisk';
+
+function getCommands() {
+  const { platform } = process;
+
+  if (platform === 'darwin') {
+    return {
+      root: ({ name }) => `/Volumes/${name}`,
+      mount: (options) => {
+        const result = run(
+          'hdiutil',
+          'attach',
+          '-nomount',
+          `ram://${options.blocks}`,
+        );
+
+        options.devicePath = result.stdout.toString().trim();
+
+        run('diskutil', 'erasevolume', 'HFS+', name, options.devicePath);
+      },
+      umount: (options) => {
+        // If the disk wasn't unmounted properly on previous run we don't know its device id
+        if (!options.devicePath) {
+          const all = run('hdiutil', 'info');
+
+          const output = all.stdout
+            .toString()
+            .split(/\n\r?/g)
+            .find((line) => line.endsWith(options.diskPath));
+
+          if (output) {
+            options.devicePath = output.split(/\s+/g)[0];
+          }
+        }
+
+        if (options.devicePath) {
+          run('hdiutil', 'detach', options.devicePath);
+        }
+      },
+    };
+  }
+
+  if (platform === 'linux') {
+    return {
+      root: ({ name }) => `/dev/shm/${name}`,
+      mount: ({ diskPath }) => {
+        run('sudo', 'mkdir', '-p', diskPath);
+        run('sudo', 'chmod', '777', diskPath);
+      },
+      umount: ({ diskPath }) => {
+        run('sudo', 'rm', '-rf', diskPath);
+      },
+    };
+  }
+
+  return null;
+}
+
+function run(command, ...args) {
+  if (!command) {
+    return;
+  }
+
+  const result = childProcess.spawnSync(command, args);
+
+  if (result.status !== 0) {
+    throw new Error(
+      `Failed command [${command} ${args.join(' ')}]: ${result.stdout} / ${
+        result.stderr
+      }`,
+    );
+  }
+
+  return result;
+}
+
+class Ramdisk {
+  constructor(opts = {}) {
+    const partialOpts = Object.assign({}, defaults, opts);
+    const options = Object.assign({}, partialOpts, {
+      blocks: partialOpts.bytes / partialOpts.blockSize,
+    });
+
+    this.options = options;
+
+    this.commands = getCommands();
+    this.options.diskPath = this.commands?.root(this.options);
+
+    // const options = Object.assign({}, opts, { root: commands.root });
+
+    this.init();
+  }
+
+  init() {
+    if (!fs.existsSync(this.options.diskPath)) {
+      console.info(
+        colors.blue(`⬡ aps:`),
+        `Initializing RAMdisk at ${this.options.diskPath}. You may be prompted for credentials`,
+      );
+      this.commands?.mount(this.options);
+    }
+
+    process.on('SIGINT', () => {
+      this.cleanup();
+    });
+
+    process.on('SIGTERM', () => {
+      this.cleanup();
+    });
+
+    process.on('exit', () => {
+      this.cleanup();
+    });
+  }
+
+  get diskPath() {
+    return this.options.diskPath;
+  }
+
+  cleanup() {
+    this.commands?.umount(this.options);
+  }
+}
+
+module.exports = { defaults, Ramdisk };

package/lib/routes.js

@@ -0,0 +1,118 @@
+/*
+  Copyright © 2018 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const { unstyle } = require('ansi-colors');
+const router = require('koa-route');
+const stringify = require('json-stringify-safe');
+
+const prep = (data) => stringify(data);
+
+const statsOptions = {
+  all: false,
+  cached: true,
+  children: true,
+  hash: true,
+  modules: true,
+  timings: true,
+  exclude: ['node_modules', 'bower_components', 'components'],
+};
+
+const setupRoutes = function setupRoutes() {
+  const { app, options } = this;
+  const events = ['build', 'done', 'invalid', 'progress'];
+  const connect = async (ctx) => {
+    if (ctx.ws) {
+      const socket = await ctx.ws();
+      const send = (data) => {
+        if (socket.readyState !== 1) {
+          return;
+        }
+        socket.send(data);
+      };
+
+      socket.build = (compilerName = '<unknown>', { wpsId }) => {
+        send(prep({ action: 'build', data: { compilerName, wpsId } }));
+      };
+
+      socket.done = (stats, { wpsId }) => {
+        const { hash } = stats;
+
+        if (socket.lastHash === hash) {
+          return;
+        }
+
+        send(prep({ action: 'done', data: { hash, wpsId } }));
+
+        socket.lastHash = hash;
+
+        const { errors = [], warnings = [] } = stats.toJson(statsOptions);
+
+        if (errors.length || warnings.length) {
+          send(
+            prep({
+              action: 'problems',
+              data: {
+                errors: errors.slice(0).map((e) => unstyle(e)),
+                hash,
+                warnings: warnings.slice(0).map((e) => unstyle(e)),
+                wpsId,
+              },
+            }),
+          );
+
+          if (errors.length) {
+            return;
+          }
+        }
+
+        if (options.hmr || options.liveReload) {
+          const action = options.liveReload ? 'reload' : 'replace';
+          send(prep({ action, data: { hash, wpsId } }));
+        }
+      };
+
+      socket.invalid = (filePath = '<unknown>', compiler) => {
+        const context =
+          compiler.context || compiler.options.context || process.cwd();
+        const fileName = filePath?.replace?.(context, '') || filePath;
+        const { wpsId } = compiler;
+
+        send(prep({ action: 'invalid', data: { fileName, wpsId } }));
+      };
+
+      socket.progress = (data) => {
+        send(prep({ action: 'progress', data }));
+      };
+
+      for (const event of events) {
+        this.on(event, socket[event]);
+
+        socket.on('close', () => {
+          this.removeListener(event, socket[event]);
+        });
+      }
+
+      // #138. handle emitted events that don't have a listener registered, and forward the message
+      // onto the client via the socket
+      const unhandled = ({ eventName, data }) =>
+        send(prep({ action: eventName, data }));
+      this.on('unhandled', unhandled);
+      socket.on('close', () => {
+        this.off('unhandled', unhandled);
+      });
+
+      send(prep({ action: 'connected' }));
+    }
+  };
+
+  app.use(router.get('/wps', connect));
+};
+
+module.exports = { setupRoutes };

package/lib/server.js

@@ -0,0 +1,129 @@
+/*
+  Copyright © 2018 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const url = require('node:url');
+const { createServer } = require('node:http');
+
+const open = require('open').default;
+
+const { getBuiltins } = require('./middleware');
+const { setupRoutes } = require('./routes');
+
+const select = (options, callback) => {
+  const types = {
+    http: createServer,
+    https: require('node:https').createServer,
+    http2: require('node:http2').createServer,
+    http2Secure: require('node:http2').createSecureServer,
+  };
+  const { http2, https } = options;
+  let server;
+  let secure = false;
+
+  if (http2) {
+    if (http2 === true) {
+      server = types.http2({}, callback);
+    } else if (http2.cert || http2.pfx) {
+      secure = true;
+      server = types.http2Secure(http2, callback);
+    } else {
+      server = types.http2(http2, callback);
+    }
+  } else if (https) {
+    secure = true;
+    server = types.https(https === true ? {} : https, callback);
+  } else {
+    server = types.http(callback);
+  }
+
+  return { secure, server };
+};
+
+const start = async function start() {
+  if (this.listening) {
+    return;
+  }
+
+  const { app } = this;
+  const { host, middleware, port, waitForBuild } = this.options;
+  const builtins = getBuiltins(app, this.options);
+
+  this.options.host = await host;
+  this.options.port = await port;
+
+  if (waitForBuild) {
+    app.use(async (_ctx, next) => {
+      await this.state.compiling;
+      await next();
+    });
+  }
+
+  // allow users to add and manipulate middleware in the config
+  await middleware(app, builtins);
+
+  // call each of the builtin middleware. methods are once'd so this has no ill-effects.
+  for (const fn of Object.values(builtins)) {
+    if (!fn.skip) {
+      fn();
+    }
+  }
+
+  setupRoutes.bind(this)();
+
+  const { secure, server } = select(this.options, app.callback());
+  const emitter = this;
+
+  this.options.secure = secure;
+
+  server.listen({ host: this.options.host, port: this.options.port });
+
+  // wait for the server to fully spin up before asking it for details
+  await {
+    // biome-ignore lint/suspicious/noThenProperty: legacy
+    then(r, f) {
+      server.on('listening', () => {
+        emitter.emit('listening', server);
+        r();
+      });
+      server.on('error', f);
+    },
+  };
+
+  this.listening = true;
+
+  const protocol = secure ? 'https' : 'http';
+  const address = server.address();
+
+  address.hostname = address.address;
+
+  // fix #131 - server address reported as 127.0.0.1 for localhost
+  if (
+    address.hostname !== this.options.host &&
+    this.options.host === 'localhost'
+  ) {
+    address.hostname = this.options.host;
+  }
+
+  // we set this so the client can use the actual hostname of the server. sometimes the net
+  // will mutate the actual hostname value (e.g. :: -> [::])
+  this.options.address = url.format(address);
+
+  const uri = `${protocol}://${this.options.address}`;
+
+  this.log.info('Server Listening on:', uri);
+
+  this.once('done', () => {
+    if (this.options.open) {
+      open(uri, this.options.open === true ? {} : this.options.open);
+    }
+  });
+};
+
+module.exports = { start };

package/lib/validate.js

@@ -0,0 +1,77 @@
+/*
+  Copyright © 2018 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const {
+  refine,
+  any,
+  nullable,
+  type,
+  partial,
+  array,
+  union,
+  integer,
+  max,
+  boolean,
+  string,
+  func,
+  literal,
+  never,
+  validate,
+} = require('superstruct');
+
+const promise = refine(any(), 'promise-like', (value) => {
+  return (
+    !!value &&
+    (typeof value === 'object' || typeof value === 'function') &&
+    typeof value.then === 'function'
+  );
+});
+
+module.exports = {
+  validate(options) {
+    const schema = partial({
+      allowMany: boolean(),
+      client: partial({
+        address: string(),
+        protocol: union([literal('ws'), literal('wss')]),
+        retry: boolean(),
+        silent: boolean(),
+      }),
+      compress: nullable(boolean()),
+      headers: nullable(type({})),
+      historyFallback: union([boolean(), type({})]),
+      hmr: union([boolean(), literal('refresh-on-failure')]),
+      host: nullable(union([promise, string()])),
+      http2: union([boolean(), type({})]),
+      https: nullable(type({})),
+      liveReload: boolean(),
+      log: partial({ level: string(), timestamp: boolean() }),
+      middleware: func(),
+      open: union([boolean(), type({})]),
+      port: union([max(integer(), 65535), promise]),
+      progress: union([boolean(), literal('minimal')]),
+      publicPath: nullable(string()),
+      ramdisk: union([boolean(), type({})]),
+      secure: never(),
+      static: nullable(
+        union([
+          string(),
+          array(string()),
+          partial({ glob: array(string()), options: type({}) }),
+        ]),
+      ),
+      status: boolean(),
+      waitForBuild: boolean(),
+    });
+    const [error, value] = validate(options, schema);
+
+    return { error, value };
+  },
+};

package/lib/ws.js

@@ -0,0 +1,41 @@
+/*
+  Copyright © 2018 Andrew Powell
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of this Source Code Form.
+*/
+const defer = require('./helpers.js').defer;
+const WebSocket = require('ws');
+
+const socketServer = new WebSocket.Server({ noServer: true });
+
+const middleware = async (ctx, next) => {
+  const deferred = defer();
+  const { upgrade = '' } = ctx.request.headers;
+  const upgradable = upgrade
+    .split(',')
+    .map((header) => header.trim())
+    .includes('websocket');
+
+  if (upgradable) {
+    ctx.ws = async () => {
+      socketServer.handleUpgrade(
+        ctx.req,
+        ctx.request.socket,
+        Buffer.alloc(0),
+        deferred.resolve,
+      );
+      ctx.respond = false;
+
+      return deferred.promise;
+    };
+  }
+
+  await next();
+};
+
+module.exports = { middleware };

package/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "anypack-plugin-serve",
+  "version": "0.1.0-alpha.1",
+  "description": "A Development Server in a Webpack Plugin",
+  "license": "MPL-2.0",
+  "repository": "onigoetz/anypack-plugin-serve",
+  "author": "onigoetz",
+  "homepage": "https://github.com/onigoetz/anypack-plugin-serve",
+  "bugs": "https://github.com/onigoetz/anypack-plugin-serve/issues",
+  "bin": "",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "scripts": {
+    "ci:lint": "biome check lib test",
+    "ci:test": "npm run test --coverage",
+    "dev": "npm run dev:clean && node node_modules/webpack-nano/bin/wp --config test/fixtures/simple/webpack.config.js",
+    "dev:clean": "del test/fixtures/multi/output/* test/fixtures/simple/output/*",
+    "dev:multi": "npm run dev:clean && node node_modules/webpack-nano/bin/wp --config test/fixtures/multi/webpack.config.js",
+    "faq:toc": "echo 'temporarily disabled' # markdown-toc -i .github/FAQ.md",
+    "format": "biome format lib test",
+    "lint": "biome check --write lib test",
+    "lint-staged": "lint-staged",
+    "test": "rstest"
+  },
+  "files": [
+    "client.js",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "webpack": "^5.0.0"
+  },
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "connect-history-api-fallback": "^2.0.0",
+    "empathic": "^2.0.0",
+    "http-proxy-middleware": "^1.0.3",
+    "json-stringify-safe": "^5.0.1",
+    "koa": "^2.5.3",
+    "koa-compress": "^5.0.1",
+    "koa-connect": "^2.0.1",
+    "koa-route": "^3.2.0",
+    "koa-static": "^5.0.0",
+    "loglevelnext": "^4.0.1",
+    "nanoid": "^5.1.6",
+    "onetime": "^7.0.0",
+    "open": "^11.0.0",
+    "superstruct": "^2.0.2",
+    "tinyglobby": "^0.2.15",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@rstest/core": "^0.7.0",
+    "@rstest/coverage-istanbul": "^0.1.0",
+    "del-cli": "7.0.0",
+    "execa": "^9.0.0",
+    "get-port": "^7.1.0",
+    "line-by-line": "^0.1.6",
+    "lint-staged": "^16.2.7",
+    "node-fetch": "^3.3.2",
+    "pre-commit": "^1.2.2",
+    "puppeteer": "^24.32.0",
+    "random-js": "^2.1.0",
+    "webpack": "^5.0.0",
+    "webpack-nano": "^1.0.0"
+  },
+  "keywords": [
+    "dev",
+    "development",
+    "devserver",
+    "serve",
+    "server",
+    "webpack"
+  ],
+  "lint-staged": {
+    "*.{js,mjs}": [
+      "biome check --write --no-errors-on-unmatched --files-ignore-unknown=true --colors=off"
+    ]
+  },
+  "nyc": {
+    "include": [
+      "lib/**/*.js"
+    ],
+    "exclude": [
+      "lib/client*.js",
+      "test/"
+    ]
+  },
+  "pre-commit": "lint-staged"
+}