emsdk-env 0.1.0 → 0.3.0

package/dist/vite.mjs

@@ -1,22 +1,699 @@
 /*!
  * name: emsdk-env
- * version: 0.1.0
+ * version: 0.3.0
  * description: Emscripten environment builder
  * author: Kouji Matsui (@kekyo@mi.kekyo.net)
  * license: MIT
  * repository.url: https://github.com/kekyo/emsdk-env
- * git.commit.hash: 32f73259bc38b9fcc19c26f3012f0b87c28963e4
+ * git.commit.hash: 4a03739b8c88111950fa216a7c10c7bfd65ea239
  */
 
-import { prepareEmsdk } from "./index.mjs";
-const emsdkEnv = (options) => ({
-  name: "emsdkEnv",
-  apply: "build",
-  enforce: "pre",
-  async buildStart() {
-    await prepareEmsdk(options);
+import { isAbsolute, resolve, relative } from "path";
+import { b as buildWasm } from "./build-CYHeaOdc.js";
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var browser = { exports: {} };
+var ms;
+var hasRequiredMs;
+function requireMs() {
+  if (hasRequiredMs) return ms;
+  hasRequiredMs = 1;
+  var s = 1e3;
+  var m = s * 60;
+  var h = m * 60;
+  var d = h * 24;
+  var w = d * 7;
+  var y = d * 365.25;
+  ms = function(val, options) {
+    options = options || {};
+    var type = typeof val;
+    if (type === "string" && val.length > 0) {
+      return parse(val);
+    } else if (type === "number" && isFinite(val)) {
+      return options.long ? fmtLong(val) : fmtShort(val);
+    }
+    throw new Error(
+      "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+    );
+  };
+  function parse(str) {
+    str = String(str);
+    if (str.length > 100) {
+      return;
+    }
+    var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      str
+    );
+    if (!match) {
+      return;
+    }
+    var n = parseFloat(match[1]);
+    var type = (match[2] || "ms").toLowerCase();
+    switch (type) {
+      case "years":
+      case "year":
+      case "yrs":
+      case "yr":
+      case "y":
+        return n * y;
+      case "weeks":
+      case "week":
+      case "w":
+        return n * w;
+      case "days":
+      case "day":
+      case "d":
+        return n * d;
+      case "hours":
+      case "hour":
+      case "hrs":
+      case "hr":
+      case "h":
+        return n * h;
+      case "minutes":
+      case "minute":
+      case "mins":
+      case "min":
+      case "m":
+        return n * m;
+      case "seconds":
+      case "second":
+      case "secs":
+      case "sec":
+      case "s":
+        return n * s;
+      case "milliseconds":
+      case "millisecond":
+      case "msecs":
+      case "msec":
+      case "ms":
+        return n;
+      default:
+        return void 0;
+    }
   }
+  function fmtShort(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return Math.round(ms2 / d) + "d";
+    }
+    if (msAbs >= h) {
+      return Math.round(ms2 / h) + "h";
+    }
+    if (msAbs >= m) {
+      return Math.round(ms2 / m) + "m";
+    }
+    if (msAbs >= s) {
+      return Math.round(ms2 / s) + "s";
+    }
+    return ms2 + "ms";
+  }
+  function fmtLong(ms2) {
+    var msAbs = Math.abs(ms2);
+    if (msAbs >= d) {
+      return plural(ms2, msAbs, d, "day");
+    }
+    if (msAbs >= h) {
+      return plural(ms2, msAbs, h, "hour");
+    }
+    if (msAbs >= m) {
+      return plural(ms2, msAbs, m, "minute");
+    }
+    if (msAbs >= s) {
+      return plural(ms2, msAbs, s, "second");
+    }
+    return ms2 + " ms";
+  }
+  function plural(ms2, msAbs, n, name) {
+    var isPlural = msAbs >= n * 1.5;
+    return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+  }
+  return ms;
+}
+var common;
+var hasRequiredCommon;
+function requireCommon() {
+  if (hasRequiredCommon) return common;
+  hasRequiredCommon = 1;
+  function setup(env) {
+    createDebug2.debug = createDebug2;
+    createDebug2.default = createDebug2;
+    createDebug2.coerce = coerce;
+    createDebug2.disable = disable;
+    createDebug2.enable = enable;
+    createDebug2.enabled = enabled;
+    createDebug2.humanize = requireMs();
+    createDebug2.destroy = destroy;
+    Object.keys(env).forEach((key) => {
+      createDebug2[key] = env[key];
+    });
+    createDebug2.names = [];
+    createDebug2.skips = [];
+    createDebug2.formatters = {};
+    function selectColor(namespace) {
+      let hash = 0;
+      for (let i = 0; i < namespace.length; i++) {
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
+      }
+      return createDebug2.colors[Math.abs(hash) % createDebug2.colors.length];
+    }
+    createDebug2.selectColor = selectColor;
+    function createDebug2(namespace) {
+      let prevTime;
+      let enableOverride = null;
+      let namespacesCache;
+      let enabledCache;
+      function debug(...args) {
+        if (!debug.enabled) {
+          return;
+        }
+        const self = debug;
+        const curr = Number(/* @__PURE__ */ new Date());
+        const ms2 = curr - (prevTime || curr);
+        self.diff = ms2;
+        self.prev = prevTime;
+        self.curr = curr;
+        prevTime = curr;
+        args[0] = createDebug2.coerce(args[0]);
+        if (typeof args[0] !== "string") {
+          args.unshift("%O");
+        }
+        let index = 0;
+        args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+          if (match === "%%") {
+            return "%";
+          }
+          index++;
+          const formatter = createDebug2.formatters[format];
+          if (typeof formatter === "function") {
+            const val = args[index];
+            match = formatter.call(self, val);
+            args.splice(index, 1);
+            index--;
+          }
+          return match;
+        });
+        createDebug2.formatArgs.call(self, args);
+        const logFn = self.log || createDebug2.log;
+        logFn.apply(self, args);
+      }
+      debug.namespace = namespace;
+      debug.useColors = createDebug2.useColors();
+      debug.color = createDebug2.selectColor(namespace);
+      debug.extend = extend;
+      debug.destroy = createDebug2.destroy;
+      Object.defineProperty(debug, "enabled", {
+        enumerable: true,
+        configurable: false,
+        get: () => {
+          if (enableOverride !== null) {
+            return enableOverride;
+          }
+          if (namespacesCache !== createDebug2.namespaces) {
+            namespacesCache = createDebug2.namespaces;
+            enabledCache = createDebug2.enabled(namespace);
+          }
+          return enabledCache;
+        },
+        set: (v) => {
+          enableOverride = v;
+        }
+      });
+      if (typeof createDebug2.init === "function") {
+        createDebug2.init(debug);
+      }
+      return debug;
+    }
+    function extend(namespace, delimiter) {
+      const newDebug = createDebug2(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+      newDebug.log = this.log;
+      return newDebug;
+    }
+    function enable(namespaces) {
+      createDebug2.save(namespaces);
+      createDebug2.namespaces = namespaces;
+      createDebug2.names = [];
+      createDebug2.skips = [];
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+      for (const ns of split) {
+        if (ns[0] === "-") {
+          createDebug2.skips.push(ns.slice(1));
+        } else {
+          createDebug2.names.push(ns);
+        }
+      }
+    }
+    function matchesTemplate(search, template) {
+      let searchIndex = 0;
+      let templateIndex = 0;
+      let starIndex = -1;
+      let matchIndex = 0;
+      while (searchIndex < search.length) {
+        if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+          if (template[templateIndex] === "*") {
+            starIndex = templateIndex;
+            matchIndex = searchIndex;
+            templateIndex++;
+          } else {
+            searchIndex++;
+            templateIndex++;
+          }
+        } else if (starIndex !== -1) {
+          templateIndex = starIndex + 1;
+          matchIndex++;
+          searchIndex = matchIndex;
+        } else {
+          return false;
+        }
+      }
+      while (templateIndex < template.length && template[templateIndex] === "*") {
+        templateIndex++;
+      }
+      return templateIndex === template.length;
+    }
+    function disable() {
+      const namespaces = [
+        ...createDebug2.names,
+        ...createDebug2.skips.map((namespace) => "-" + namespace)
+      ].join(",");
+      createDebug2.enable("");
+      return namespaces;
+    }
+    function enabled(name) {
+      for (const skip of createDebug2.skips) {
+        if (matchesTemplate(name, skip)) {
+          return false;
+        }
+      }
+      for (const ns of createDebug2.names) {
+        if (matchesTemplate(name, ns)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function coerce(val) {
+      if (val instanceof Error) {
+        return val.stack || val.message;
+      }
+      return val;
+    }
+    function destroy() {
+      console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+    }
+    createDebug2.enable(createDebug2.load());
+    return createDebug2;
+  }
+  common = setup;
+  return common;
+}
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser.exports;
+  hasRequiredBrowser = 1;
+  (function(module, exports$1) {
+    exports$1.formatArgs = formatArgs;
+    exports$1.save = save;
+    exports$1.load = load;
+    exports$1.useColors = useColors;
+    exports$1.storage = localstorage();
+    exports$1.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports$1.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports$1.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports$1.storage.setItem("debug", namespaces);
+        } else {
+          exports$1.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports$1.storage.getItem("debug") || exports$1.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = requireCommon()(exports$1);
+    const { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  })(browser, browser.exports);
+  return browser.exports;
+}
+var browserExports = requireBrowser();
+const __screwUpDefaultImportModule0 = /* @__PURE__ */ getDefaultExportFromCjs(browserExports);
+const createDebug = __resolveDefaultExport(__screwUpDefaultImportModule0);
+globalThis.__screwUpIsInCJS_93c24de65540 = false;
+function __resolveDefaultExport(module, isESM) {
+  const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_93c24de65540 === true;
+  const maybe = module;
+  const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+  const unwrapNamespaceDefault = (value) => {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const inner = value;
+    const isModule = inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module";
+    if (isModule && "default" in inner) {
+      return inner.default;
+    }
+    return value;
+  };
+  const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+  if (__isInCJS) {
+    return hasDefault ? resolvedDefault != null ? resolvedDefault : module : module;
+  }
+  return hasDefault ? resolvedDefault != null ? resolvedDefault : module : module;
+}
+const createViteLoggerAdapter = (viteLogger, logLevel, prefix) => {
+  const debug = createDebug("vite:plugin:emsdk-vite");
+  return {
+    debug: (msg) => {
+      debug(msg);
+    },
+    info: logLevel !== "silent" ? (msg) => viteLogger.info(`[${prefix}]: ${msg}`) : () => {
+    },
+    warn: logLevel === "warn" || logLevel === "info" || logLevel === "error" ? (msg) => viteLogger.warn(`[${prefix}]: ${msg}`) : () => {
+    },
+    error: logLevel !== "silent" ? (msg) => viteLogger.error(`[${prefix}]: ${msg}`) : () => {
+    }
+  };
+};
+const DEFAULT_WASM_SRC_DIR = "wasm";
+const buildRuns = /* @__PURE__ */ new Map();
+const resolvePath = (rootDir, value) => isAbsolute(value) ? value : resolve(rootDir, value);
+const expandPlaceholders = (value, env, label) => value.replace(/\{([A-Z0-9_]+)\}/g, (_match, key) => {
+  const replacement = env[key];
+  if (replacement === void 0) {
+    throw new Error(`Unknown placeholder {${key}} in ${label}.`);
+  }
+  return replacement;
 });
+const expandArray = (values, env, label) => values.map((value) => expandPlaceholders(value, env, label));
+const resolveIncludeDirs = (includeDirs, env, rootDir) => {
+  const expanded = expandArray(includeDirs, env, "includeDirs");
+  return expanded.map((value) => resolvePath(rootDir, value));
+};
+const createBuildOptions = (options, resolvedConfig, logger) => {
+  const { emsdk, srcDir, outDir, buildDir, cleanupBuildDir, ...rule } = options;
+  return {
+    rule,
+    root: resolvedConfig.root,
+    logger,
+    ...emsdk !== void 0 ? { emsdk } : {},
+    ...srcDir !== void 0 ? { srcDir } : {},
+    ...outDir !== void 0 ? { outDir } : {},
+    ...buildDir !== void 0 ? { buildDir } : {},
+    ...cleanupBuildDir !== void 0 ? { cleanupBuildDir } : {}
+  };
+};
+const isSubPath = (parentDir, targetPath) => {
+  const rel = relative(parentDir, targetPath);
+  if (rel === "") {
+    return true;
+  }
+  return !rel.startsWith("..") && !isAbsolute(rel);
+};
+const resolveWatchTargets = (options, resolvedConfig) => {
+  var _a, _b;
+  const rootDir = resolvedConfig.root;
+  const baseEnv = {
+    ROOT: rootDir
+  };
+  const rawSrcDir = expandPlaceholders(
+    (_a = options.srcDir) != null ? _a : DEFAULT_WASM_SRC_DIR,
+    baseEnv,
+    "srcDir"
+  );
+  const srcDir = resolvePath(rootDir, rawSrcDir);
+  const envWithDirs = {
+    ROOT: rootDir,
+    SRC_DIR: srcDir
+  };
+  const patterns = /* @__PURE__ */ new Set();
+  const baseDirs = /* @__PURE__ */ new Set();
+  const resolvedIncludeDirs = [];
+  patterns.add(srcDir);
+  baseDirs.add(srcDir);
+  const addIncludePatterns = (targetIncludeDirs, targetName) => {
+    if (!targetIncludeDirs || targetIncludeDirs.length === 0) {
+      return;
+    }
+    const env = targetName ? { ...envWithDirs, TARGET_NAME: targetName } : envWithDirs;
+    const resolvedDirs = resolveIncludeDirs(targetIncludeDirs, env, rootDir);
+    for (const dir of resolvedDirs) {
+      patterns.add(dir);
+      baseDirs.add(dir);
+      resolvedIncludeDirs.push(dir);
+    }
+  };
+  addIncludePatterns((_b = options.common) == null ? void 0 : _b.includeDirs, void 0);
+  for (const [targetName, target] of Object.entries(options.targets)) {
+    addIncludePatterns(target.includeDirs, targetName);
+  }
+  return {
+    srcDir,
+    includeDirs: resolvedIncludeDirs,
+    patterns: [...patterns],
+    baseDirs: [...baseDirs]
+  };
+};
+const setupDevServer = async (server, options, resolvedConfig) => {
+  var _a;
+  const logger = createViteLoggerAdapter(
+    resolvedConfig.logger,
+    (_a = resolvedConfig.logLevel) != null ? _a : "info",
+    "emsdk-env"
+  );
+  const buildOptions = createBuildOptions(options, resolvedConfig, logger);
+  const watchTargets = resolveWatchTargets(options, resolvedConfig);
+  logger.debug(`watch root: ${resolvedConfig.root}`);
+  logger.debug(`watch srcDir: ${watchTargets.srcDir}`);
+  logger.debug(
+    `watch includeDirs: ${watchTargets.includeDirs.length > 0 ? watchTargets.includeDirs.join(", ") : "(none)"}`
+  );
+  logger.debug(`watch patterns: ${watchTargets.patterns.join(", ")}`);
+  logger.debug(`watch baseDirs: ${watchTargets.baseDirs.join(", ")}`);
+  if (watchTargets.patterns.length > 0) {
+    server.watcher.add(watchTargets.patterns);
+  }
+  let buildQueue = Promise.resolve();
+  const queueBuild = async (shouldReload) => {
+    buildQueue = buildQueue.then(async () => {
+      try {
+        await buildWasm(buildOptions);
+        if (shouldReload) {
+          server.ws.send({ type: "full-reload" });
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown wasm build error.";
+        logger.error(`Wasm build failed: ${message}`);
+      }
+    });
+    return buildQueue;
+  };
+  const onWatchEvent = async (eventPath) => {
+    const resolvedPath = isAbsolute(eventPath) ? eventPath : resolve(resolvedConfig.root, eventPath);
+    if (!watchTargets.baseDirs.some((dir) => isSubPath(dir, resolvedPath))) {
+      return;
+    }
+    await queueBuild(true);
+  };
+  server.watcher.on("add", onWatchEvent);
+  server.watcher.on("change", onWatchEvent);
+  server.watcher.on("unlink", onWatchEvent);
+  await queueBuild(false);
+};
+const emsdkEnv = (options) => {
+  let resolvedConfig;
+  return {
+    name: "emsdkEnv",
+    enforce: "pre",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async buildStart() {
+      var _a;
+      if (!resolvedConfig) {
+        throw new Error("Vite config was not resolved.");
+      }
+      if (resolvedConfig.command !== "build") {
+        return;
+      }
+      const logger = createViteLoggerAdapter(
+        resolvedConfig.logger,
+        (_a = resolvedConfig.logLevel) != null ? _a : "info",
+        "emsdk-env"
+      );
+      const buildOptions = createBuildOptions(options, resolvedConfig, logger);
+      const buildKey = resolvedConfig.root;
+      const existing = buildRuns.get(buildKey);
+      if (existing) {
+        await existing;
+        return;
+      }
+      const run = (async () => {
+        try {
+          await buildWasm(buildOptions);
+        } finally {
+          buildRuns.delete(buildKey);
+        }
+      })();
+      buildRuns.set(buildKey, run);
+      await run;
+    },
+    async configureServer(server) {
+      if (!resolvedConfig) {
+        throw new Error("Vite config was not resolved.");
+      }
+      if (resolvedConfig.command !== "serve") {
+        return;
+      }
+      await setupDevServer(server, options, resolvedConfig);
+    }
+  };
+};
 export {
   emsdkEnv as default
 };