@unpackjs/core 1.5.4 → 1.6.1

package/dist/thread-loader/worker.js

@@ -0,0 +1,382 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname, __filename;
+var init_esm = __esm({
+  "../../node_modules/.pnpm/@modern-js+module-tools@2.60.5_typescript@5.5.4/node_modules/@modern-js/module-tools/shims/esm.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+    __filename = /* @__PURE__ */ getFilename();
+  }
+});
+import fs from "node:fs";
+import NativeModule from "node:module";
+import querystring from "node:querystring";
+import loaderRunner from "loader-runner";
+import readBuffer from "./readBuffer.js";
+import { replacer, reviver } from "./serializer.js";
+import { utils } from "./utils.js";
+var require_worker = __commonJS({
+  "src/thread-loader/worker.js"(exports) {
+    init_esm();
+    const asyncQueue = require("neo-async/queue.js");
+    const writePipe = fs.createWriteStream(null, { fd: 3 });
+    const readPipe = fs.createReadStream(null, { fd: 4 });
+    writePipe.on("finish", onTerminateWrite);
+    readPipe.on("end", onTerminateRead);
+    writePipe.on("close", onTerminateWrite);
+    readPipe.on("close", onTerminateRead);
+    readPipe.on("error", onError);
+    writePipe.on("error", onError);
+    const PARALLEL_JOBS = +process.argv[2] || 20;
+    let terminated = false;
+    let nextQuestionId = 0;
+    const callbackMap = /* @__PURE__ */ Object.create(null);
+    function onError(error) {
+      console.error(error);
+    }
+    function onTerminateRead() {
+      terminateRead();
+    }
+    function onTerminateWrite() {
+      terminateWrite();
+    }
+    function writePipeWrite(...args) {
+      if (!terminated) {
+        writePipe.write(...args);
+      }
+    }
+    function writePipeCork() {
+      if (!terminated) {
+        writePipe.cork();
+      }
+    }
+    function writePipeUncork() {
+      if (!terminated) {
+        writePipe.uncork();
+      }
+    }
+    function terminateRead() {
+      terminated = true;
+      readPipe.removeAllListeners();
+    }
+    function terminateWrite() {
+      terminated = true;
+      writePipe.removeAllListeners();
+    }
+    function terminate() {
+      terminateRead();
+      terminateWrite();
+    }
+    function toErrorObj(err) {
+      return {
+        message: err.message,
+        details: err.details,
+        stack: err.stack,
+        hideStack: err.hideStack
+      };
+    }
+    function toNativeError(obj) {
+      if (!obj)
+        return null;
+      const err = new Error(obj.message);
+      err.details = obj.details;
+      err.missing = obj.missing;
+      return err;
+    }
+    function writeJson(data) {
+      writePipeCork();
+      process.nextTick(() => {
+        writePipeUncork();
+      });
+      const lengthBuffer = Buffer.alloc(4);
+      const messageBuffer = Buffer.from(JSON.stringify(data, replacer), "utf-8");
+      lengthBuffer.writeInt32BE(messageBuffer.length, 0);
+      writePipeWrite(lengthBuffer);
+      writePipeWrite(messageBuffer);
+    }
+    const queue = asyncQueue(({ id, data }, taskCallback) => {
+      try {
+        const resolveWithOptions = (context, request, callback, options) => {
+          callbackMap[nextQuestionId] = callback;
+          writeJson({
+            type: "resolve",
+            id,
+            questionId: nextQuestionId,
+            context,
+            request,
+            options
+          });
+          nextQuestionId += 1;
+        };
+        const buildDependencies = [];
+        loaderRunner.runLoaders(
+          {
+            loaders: data.loaders,
+            resource: data.resource,
+            readResource: fs.readFile.bind(fs),
+            context: {
+              version: 2,
+              fs,
+              loadModule: (request, callback) => {
+                callbackMap[nextQuestionId] = (error, result) => callback(error, ...result);
+                writeJson({
+                  type: "loadModule",
+                  id,
+                  questionId: nextQuestionId,
+                  request
+                });
+                nextQuestionId += 1;
+              },
+              resolve: (context, request, callback) => {
+                resolveWithOptions(context, request, callback);
+              },
+              getResolve: (options) => (context, request, callback) => {
+                if (callback) {
+                  resolveWithOptions(context, request, callback, options);
+                } else {
+                  return new Promise((resolve, reject) => {
+                    resolveWithOptions(
+                      context,
+                      request,
+                      (err, result) => {
+                        if (err) {
+                          reject(err);
+                        } else {
+                          resolve(result);
+                        }
+                      },
+                      options
+                    );
+                  });
+                }
+              },
+              // Not an arrow function because it uses this
+              getOptions() {
+                const loader = this.loaders[this.loaderIndex];
+                let { options } = loader;
+                if (typeof options === "string") {
+                  if (options.substr(0, 1) === "{" && options.substr(-1) === "}") {
+                    try {
+                      options = JSON.parse(options);
+                    } catch (e) {
+                      throw new Error(`Cannot parse string options: ${e.message}`);
+                    }
+                  } else {
+                    options = querystring.parse(options, "&", "=", {
+                      maxKeys: 0
+                    });
+                  }
+                }
+                if (options === null || options === void 0) {
+                  options = {};
+                }
+                return options;
+              },
+              emitWarning: (warning) => {
+                writeJson({
+                  type: "emitWarning",
+                  id,
+                  data: toErrorObj(warning)
+                });
+              },
+              emitError: (error) => {
+                writeJson({
+                  type: "emitError",
+                  id,
+                  data: toErrorObj(error)
+                });
+              },
+              exec: (code, filename) => {
+                const module2 = new NativeModule(filename, exports);
+                module2.paths = NativeModule._nodeModulePaths(exports.context);
+                module2.filename = filename;
+                module2._compile(code, filename);
+                return module2.exports;
+              },
+              addBuildDependency: (filename) => {
+                buildDependencies.push(filename);
+              },
+              getLogger: (name) => {
+                function writeLoggerJson(severity, message) {
+                  writeJson({
+                    type: "logger",
+                    id,
+                    data: { severity, name, message }
+                  });
+                }
+                writeJson({
+                  type: "getLogger",
+                  id,
+                  data: { name }
+                });
+                const loggers = [
+                  "error",
+                  "warn",
+                  "info",
+                  "log",
+                  "debug",
+                  "trace",
+                  "group",
+                  "groupEnd",
+                  "groupCollapsed",
+                  "status",
+                  "clear",
+                  "profile",
+                  "profileEnd"
+                ];
+                const fnMap = {};
+                for (const logger of loggers) {
+                  fnMap[logger] = (...args) => {
+                    writeLoggerJson(logger, args);
+                  };
+                }
+                return fnMap;
+              },
+              options: {
+                context: data.optionsContext
+              },
+              webpack: true,
+              "thread-loader": true,
+              sourceMap: data.sourceMap,
+              target: data.target,
+              minimize: data.minimize,
+              resourceQuery: data.resourceQuery,
+              rootContext: data.rootContext,
+              _compilation: data._compilation,
+              _compiler: data._compiler,
+              resourcePath: data.resourcePath,
+              utils
+            }
+          },
+          (err, lrResult) => {
+            const { result, cacheable, fileDependencies, contextDependencies, missingDependencies } = lrResult;
+            const buffersToSend = [];
+            const convertedResult = Array.isArray(result) && result.map((item) => {
+              const isBuffer = Buffer.isBuffer(item);
+              if (isBuffer) {
+                buffersToSend.push(item);
+                return {
+                  buffer: true
+                };
+              }
+              if (typeof item === "string") {
+                const stringBuffer = Buffer.from(item, "utf-8");
+                buffersToSend.push(stringBuffer);
+                return {
+                  buffer: true,
+                  string: true
+                };
+              }
+              return {
+                data: item
+              };
+            });
+            writeJson({
+              type: "job",
+              id,
+              error: err && toErrorObj(err),
+              result: {
+                result: convertedResult,
+                cacheable,
+                fileDependencies,
+                contextDependencies,
+                missingDependencies,
+                buildDependencies
+              },
+              data: buffersToSend.map((buffer) => buffer.length)
+            });
+            buffersToSend.forEach((buffer) => {
+              writePipeWrite(buffer);
+            });
+            setImmediate(taskCallback);
+          }
+        );
+      } catch (e) {
+        writeJson({
+          type: "job",
+          id,
+          error: toErrorObj(e)
+        });
+        taskCallback();
+      }
+    }, PARALLEL_JOBS);
+    function dispose() {
+      terminate();
+      queue.kill();
+      process.exit(0);
+    }
+    function onMessage(message) {
+      try {
+        const { type, id } = message;
+        switch (type) {
+          case "job": {
+            queue.push(message);
+            break;
+          }
+          case "result": {
+            const { error, result } = message;
+            const callback = callbackMap[id];
+            if (callback) {
+              const nativeError = toNativeError(error);
+              callback(nativeError, result);
+            } else {
+              console.error(`Worker got unexpected result id ${id}`);
+            }
+            delete callbackMap[id];
+            break;
+          }
+          case "warmup": {
+            const { requires } = message;
+            requires.forEach((r) => require(r));
+            break;
+          }
+          default: {
+            console.error(`Worker got unexpected job type ${type}`);
+            break;
+          }
+        }
+      } catch (e) {
+        console.error(`Error in worker ${e}`);
+      }
+    }
+    function readNextMessage() {
+      readBuffer(readPipe, 4, (lengthReadError, lengthBuffer) => {
+        if (lengthReadError) {
+          console.error(`Failed to communicate with main process (read length) ${lengthReadError}`);
+          return;
+        }
+        const length = lengthBuffer.length && lengthBuffer.readInt32BE(0);
+        if (length === 0) {
+          dispose();
+          return;
+        }
+        readBuffer(readPipe, length, (messageError, messageBuffer) => {
+          if (terminated) {
+            return;
+          }
+          if (messageError) {
+            console.error(`Failed to communicate with main process (read message) ${messageError}`);
+            return;
+          }
+          const messageString = messageBuffer.toString("utf-8");
+          const message = JSON.parse(messageString, reviver);
+          onMessage(message);
+          setImmediate(() => readNextMessage());
+        });
+      });
+    }
+    readNextMessage();
+  }
+});
+export default require_worker();

package/dist/thread-loader/workerPools.cjs

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var workerPools_exports = {};
+__export(workerPools_exports, {
+  getPool: () => getPool
+});
+module.exports = __toCommonJS(workerPools_exports);
+var import_node_os = __toESM(require("node:os"));
+var import_WorkerPool = __toESM(require("./WorkerPool.cjs"));
+const workerPools = /* @__PURE__ */ Object.create(null);
+function calculateNumberOfWorkers() {
+  const cpus = import_node_os.default.cpus() || { length: 1 };
+  return Math.max(1, cpus.length - 1);
+}
+function getPool(options) {
+  const workerPoolOptions = {
+    name: options.name || "",
+    numberOfWorkers: options.workers || calculateNumberOfWorkers(),
+    workerNodeArgs: options.workerNodeArgs,
+    workerParallelJobs: options.workerParallelJobs || 20,
+    poolTimeout: options.poolTimeout || 500,
+    poolParallelJobs: options.poolParallelJobs || 200,
+    poolRespawn: options.poolRespawn || false
+  };
+  const tpKey = JSON.stringify(workerPoolOptions);
+  workerPools[tpKey] = workerPools[tpKey] || new import_WorkerPool.default(workerPoolOptions);
+  return workerPools[tpKey];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPool
+});

package/dist/thread-loader/workerPools.js

@@ -0,0 +1,33 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+import os from "node:os";
+import WorkerPool from "./WorkerPool.js";
+const workerPools = /* @__PURE__ */ Object.create(null);
+function calculateNumberOfWorkers() {
+  const cpus = os.cpus() || { length: 1 };
+  return Math.max(1, cpus.length - 1);
+}
+function getPool(options) {
+  const workerPoolOptions = {
+    name: options.name || "",
+    numberOfWorkers: options.workers || calculateNumberOfWorkers(),
+    workerNodeArgs: options.workerNodeArgs,
+    workerParallelJobs: options.workerParallelJobs || 20,
+    poolTimeout: options.poolTimeout || 500,
+    poolParallelJobs: options.poolParallelJobs || 200,
+    poolRespawn: options.poolRespawn || false
+  };
+  const tpKey = JSON.stringify(workerPoolOptions);
+  workerPools[tpKey] = workerPools[tpKey] || new WorkerPool(workerPoolOptions);
+  return workerPools[tpKey];
+}
+export {
+  getPool
+};

package/dist/typed-css-modules/index.cjs

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var typed_css_modules_exports = {};
+module.exports = __toCommonJS(typed_css_modules_exports);
+__reExport(typed_css_modules_exports, require("./plugin.cjs"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./plugin.cjs")
+});

package/dist/typed-css-modules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/typed-css-modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed-css-modules/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/typed-css-modules/index.js

@@ -0,0 +1,10 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+export * from "./plugin.js";