emsdk-env 0.3.0 → 0.5.0

package/README.md

@@ -9,14 +9,13 @@ A Vite plugin that automatically builds WASM C/C++ source code using the Emscrip
 
 ---
 
-WIP:
-
 ## What is this?
 
-This is a Vite plugin that automatically downloads and manages the Emscripten SDK, and makes it possible to automatically build WASM C/C++ code in your project.
+This is a Vite plugin that automatically downloads and manages the [Emscripten SDK](https://github.com/emscripten-core/emsdk),
+and makes it possible to automatically build WASM C/C++ code in your project.
 With this plugin, you can easily set up a WASM C/C++ development environment in your Vite project.
 
-Usage is simple. Just add this Vite plugin package to your project and initialize the plugin in `vite.config.ts` like this:
+Usage is simple. Just add this Vite plugin package to your project and initialize the plugin in `vite.config` like this:
 
 ```typescript
 // `vite.config.ts`
@@ -57,6 +56,8 @@ You can focus on writing C/C++ code just like you would TypeScript/JavaScript co
 - Simplified specification of export symbols
 - Ability to generate multiple target WASM binaries
 - Customizable directory paths, compile options, and linker options
+- Archive libraries (`*.a`) can be built and referenced
+- WASM libraries can be distributed and referenced via NPM packages
 
 ---
 
@@ -70,6 +71,9 @@ Add to `devDependencies` (emsdk-env itself does not require runtime code):
 $ npm install -D emsdk-env
 ```
 
+- emsdk-env automatically downloads and caches the Emscripten SDK (located under `~/.cache/emsdk-env/`).
+  Therefore, you do not need to manually set up the Emscripten SDK.
+
 ### C/C++ Source Code and Binary Placement
 
 By default, C/C++ source code is placed in the `wasm/` directory under your project,
@@ -88,6 +92,19 @@ project/
     └── add.c
 ```
 
+- In addition to the above, a temporary build directory is created under the OS temp directory.
+  The default location is `${TMPDIR}/emsdk-env` (typically `/tmp/emsdk-env` on Unix).
+  This directory is used during the build process and is typically deleted after the build completes.
+  If you override `buildDir` to point inside the project, add it to `.gitignore`.
+
+Of course, you can change these. Specify them in the Vite plugin options.
+
+You might find it odd that the built binary is placed in `src/wasm/`, but this is because the Vite server defaults to a path where it can easily access WASM binaries.
+
+If you plan to operate with the default settings, there is essentially no configuration work required.
+
+Other topics include features such as explicitly specifying source files, applying multiple compile options separately, handling multiple target outputs, generating and referencing archive library files, and compilation and referencing NPM packages.
+
 ### Documents
 
 For more information, please visit repository and refer README: [emsdk-env](https://github.com/kekyo/emsdk-env)

package/dist/{build-DdEthYh8.cjs → build-Djw1ummW.cjs}

@@ -1,14 +1,36 @@
 /*!
  * name: emsdk-env
- * version: 0.3.0
+ * version: 0.5.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: 4a03739b8c88111950fa216a7c10c7bfd65ea239
+ * git.commit.hash: f54983861d59656c8f39fd46d984c1b373100dde
  */
 
 "use strict";
+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 __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
+));
 const promises = require("fs/promises");
 const os = require("os");
 const glob = require("glob");
@@ -502,6 +524,22 @@ const resolveEmccCommand = async (env, emsdkRoot) => {
   }
   return "emcc";
 };
+const resolveEmarCommand = async (env, emsdkRoot) => {
+  if (env.EMAR) {
+    return env.EMAR;
+  }
+  if (env.EMSCRIPTEN) {
+    const candidate = path.join(env.EMSCRIPTEN, "emar");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  const fallback = path.join(emsdkRoot, "upstream", "emscripten", "emar");
+  if (await pathExists(fallback)) {
+    return fallback;
+  }
+  return "emar";
+};
 const createConsoleLogger = (prefix) => {
   return {
     debug: (msg) => console.debug(`[${prefix}]: ${msg}`),
@@ -511,7 +549,11 @@ const createConsoleLogger = (prefix) => {
   };
 };
 const DEFAULT_WASM_SRC_DIR = "wasm";
+const DEFAULT_WASM_INCLUDE_DIR = "include";
 const DEFAULT_WASM_OUT_DIR = path.join("src", "wasm");
+const DEFAULT_WASM_LIB_DIR = "lib";
+const DEFAULT_IMPORT_INCLUDE_DIR = "include";
+const DEFAULT_IMPORT_LIB_DIR = "lib";
 const DEFAULT_WASM_BUILD_DIR = path.join(os.tmpdir(), "emsdk-env");
 const DEFAULT_EMSDK_TARGET_VERSION = "latest";
 let buildSequence = 0;
@@ -532,6 +574,7 @@ const createBuildId = () => {
   return `${timestamp}_${seq}_${process.pid}`;
 };
 const ensureArray = (value) => value != null ? value : [];
+const resolveTargetType = (value) => value != null ? value : "wasm";
 const normalizePrepareOptions = (options) => {
   const { targetVersion, ...rest } = options != null ? options : {};
   return {
@@ -593,11 +636,11 @@ const createEnvForBuild = (baseEnv, overrides) => ({
   ...baseEnv,
   ...overrides
 });
-const resolveTargetOutFile = (targetName, targetOutFile, env, outDir) => {
+const resolveTargetOutFile = (targetName, targetOutFile, env, baseDir, extension) => {
   if (targetOutFile) {
-    return resolveOutFile(targetOutFile, env, outDir);
+    return resolveOutFile(targetOutFile, env, baseDir);
   }
-  return path.resolve(outDir, `${targetName}.wasm`);
+  return path.resolve(baseDir, `${targetName}.${extension}`);
 };
 const resolveTargetSources = async (targetSources, env, srcDir) => {
   const patterns = targetSources && targetSources.length > 0 ? targetSources : [path.join(srcDir, "**", "*.c"), path.join(srcDir, "**", "*.cpp")];
@@ -622,6 +665,118 @@ const dedupeSources = (sources) => {
   }
   return deduped;
 };
+const dedupeValues = (values) => {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    deduped.push(value);
+  }
+  return deduped;
+};
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const resolvePackageJsonPath = async (startPath, packageName) => {
+  let current = path.dirname(startPath);
+  for (; ; ) {
+    const candidate = path.join(current, "package.json");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      throw new Error(`package.json not found for import: ${packageName}`);
+    }
+    current = parent;
+  }
+};
+const loadPackageJson = async (packageJsonPath, packageName) => {
+  try {
+    const raw = await promises.readFile(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isRecord(parsed)) {
+      throw new Error("package.json must be an object.");
+    }
+    return parsed;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Failed to read package.json for import ${packageName}: ${message}`
+    );
+  }
+};
+const resolveImportPaths = async (resolver, packageName) => {
+  let resolvedEntry;
+  try {
+    resolvedEntry = resolver.resolve(packageName);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to resolve import ${packageName}: ${message}`);
+  }
+  const packageJsonPath = await resolvePackageJsonPath(
+    resolvedEntry,
+    packageName
+  );
+  const packageRoot = path.dirname(packageJsonPath);
+  const packageJson = await loadPackageJson(packageJsonPath, packageName);
+  const emsdkConfigRaw = packageJson["emsdk-env"];
+  if (emsdkConfigRaw !== void 0 && !isRecord(emsdkConfigRaw)) {
+    throw new Error(
+      `Invalid emsdk-env config for import ${packageName}: expected an object.`
+    );
+  }
+  const includeRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.include : void 0;
+  if (includeRaw !== void 0 && typeof includeRaw !== "string") {
+    throw new Error(
+      `Invalid emsdk-env include for import ${packageName}: expected a string.`
+    );
+  }
+  const libRaw = isRecord(emsdkConfigRaw) ? emsdkConfigRaw.lib : void 0;
+  if (libRaw !== void 0 && typeof libRaw !== "string") {
+    throw new Error(
+      `Invalid emsdk-env lib for import ${packageName}: expected a string.`
+    );
+  }
+  const includeRel = includeRaw != null ? includeRaw : DEFAULT_IMPORT_INCLUDE_DIR;
+  const libRel = libRaw != null ? libRaw : DEFAULT_IMPORT_LIB_DIR;
+  const includeDir = path.resolve(packageRoot, includeRel);
+  const libDir = path.resolve(packageRoot, libRel);
+  const includeExists = await pathExists(includeDir);
+  const libExists = await pathExists(libDir);
+  if (!includeExists && !libExists) {
+    throw new Error(
+      `Import ${packageName} does not provide include or lib directories.`
+    );
+  }
+  return {
+    includeDir: includeExists ? includeDir : void 0,
+    libDir: libExists ? libDir : void 0
+  };
+};
+const resolveImportDirectories = async (rootDir, imports) => {
+  if (imports.length === 0) {
+    return { includeDirs: [], libDirs: [] };
+  }
+  const moduleApi = await import("node:module");
+  const resolver = moduleApi.createRequire(path.resolve(rootDir, "package.json"));
+  const includeDirs = [];
+  const libDirs = [];
+  for (const packageName of imports) {
+    const resolved = await resolveImportPaths(resolver, packageName);
+    if (resolved.includeDir) {
+      includeDirs.push(resolved.includeDir);
+    }
+    if (resolved.libDir) {
+      libDirs.push(resolved.libDir);
+    }
+  }
+  return {
+    includeDirs: dedupeValues(includeDirs),
+    libDirs: dedupeValues(libDirs)
+  };
+};
 const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
   const resolvedOptions = expandArray(options, env, "options");
   const includeArgs = resolveIncludeDirs(includeDirs, env, rootDir).map(
@@ -631,15 +786,15 @@ const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
   return { resolvedOptions, includeArgs, defineArgs };
 };
 const buildWasm = async (options) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
   if (!options) {
     throw new TypeError("options must be provided.");
   }
   if (!options.rule || !options.rule.targets) {
     throw new TypeError("rule targets must be provided.");
   }
-  const targets = Object.entries(options.rule.targets);
-  if (targets.length === 0) {
+  const targetEntries = Object.entries(options.rule.targets);
+  if (targetEntries.length === 0) {
     throw new TypeError("rule targets must not be empty.");
   }
   const logger = (_a = options.logger) != null ? _a : createConsoleLogger("emsdk-env");
@@ -656,57 +811,118 @@ const buildWasm = async (options) => {
     baseEnv,
     "srcDir"
   );
+  const rawIncludeDir = expandPlaceholders(
+    (_d = options.includeDir) != null ? _d : DEFAULT_WASM_INCLUDE_DIR,
+    baseEnv,
+    "includeDir"
+  );
   const rawOutDir = expandPlaceholders(
-    (_d = options.outDir) != null ? _d : DEFAULT_WASM_OUT_DIR,
+    (_e = options.outDir) != null ? _e : DEFAULT_WASM_OUT_DIR,
     baseEnv,
     "outDir"
   );
+  const rawLibDir = expandPlaceholders(
+    (_f = options.libDir) != null ? _f : DEFAULT_WASM_LIB_DIR,
+    baseEnv,
+    "libDir"
+  );
   const rawBuildDir = expandPlaceholders(
-    (_e = options.buildDir) != null ? _e : DEFAULT_WASM_BUILD_DIR,
+    (_g = options.buildDir) != null ? _g : DEFAULT_WASM_BUILD_DIR,
     baseEnv,
     "buildDir"
   );
   const srcDir = resolvePath(rootDir, rawSrcDir);
+  const includeDir = resolvePath(rootDir, rawIncludeDir);
   const outDir = resolvePath(rootDir, rawOutDir);
+  const libDir = resolvePath(rootDir, rawLibDir);
   const buildDir = resolvePath(rootDir, rawBuildDir);
   const buildId = createBuildId();
   const buildRunDir = path.resolve(buildDir, buildId);
-  const cleanupBuildDir = (_f = options.cleanupBuildDir) != null ? _f : true;
-  const parallel = (_g = options.parallel) != null ? _g : true;
+  const cleanupBuildDir = (_h = options.cleanupBuildDir) != null ? _h : true;
+  const parallel = (_i = options.parallel) != null ? _i : true;
   const envWithDirs = {
     ...emsdkEnv,
     ROOT: rootDir,
     SRC_DIR: srcDir,
+    INCLUDE_DIR: includeDir,
     OUT_DIR: outDir,
+    LIB_DIR: libDir,
     BUILD_DIR: buildDir
   };
   const emccCommand = await resolveEmccCommand(envWithDirs, emsdkRoot);
-  const common = (_h = options.rule.common) != null ? _h : {};
+  const common = (_j = options.rule.common) != null ? _j : {};
+  const commonIncludeDirs = common.includeDirs === void 0 ? [includeDir] : common.includeDirs;
+  const importDirectories = await resolveImportDirectories(
+    rootDir,
+    ensureArray(options.imports)
+  );
+  const importIncludeDirs = importDirectories.includeDirs;
+  const importLibDirs = importDirectories.libDirs;
+  const linkLibDirs = dedupeValues([libDir, ...importLibDirs]);
+  logger.debug(`Detected rootDir: '${rootDir}'`);
+  logger.debug(`Detected srcDir: '${srcDir}'`);
+  logger.debug(`Detected outDir: '${outDir}'`);
+  logger.debug(`Detected libDir: '${libDir}'`);
+  logger.debug(`Detected buildDir: '${buildDir}'`);
+  logger.debug(`Detected buildId: '${buildId}'`);
+  logger.debug(`Detected buildRunDir: '${buildRunDir}'`);
+  logger.debug(`Detected cleanupBuildDir: ${cleanupBuildDir}`);
+  logger.debug(`Detected parallel: ${parallel}`);
+  logger.debug(`Detected emccCommand: '${emccCommand}'`);
+  logger.debug(
+    `Detected importIncludeDirs: [${importIncludeDirs.map((p) => `'${p}'`).join(",")}]`
+  );
+  logger.debug(
+    `Detected importLibDirs: [${importLibDirs.map((p) => `'${p}'`).join(",")}]`
+  );
   await ensureDirectory(outDir);
+  await ensureDirectory(libDir);
   await ensureDirectory(buildDir);
   await promises.rm(buildRunDir, { recursive: true, force: true });
   await ensureDirectory(buildRunDir);
+  const hasArchiveTargets = targetEntries.some(
+    ([, target]) => resolveTargetType(target.type) === "archive"
+  );
+  const emarCommand = hasArchiveTargets ? await resolveEmarCommand(envWithDirs, emsdkRoot) : void 0;
+  if (emarCommand) {
+    logger.debug(`Detected emarCommand: '${emarCommand}'`);
+  }
   const outFiles = {};
-  try {
-    for (const [targetName, target] of targets) {
-      const mergedLinkOptions = [
+  const buildTargets = async (expectedType) => {
+    var _a2;
+    for (const [targetName, target] of targetEntries) {
+      const targetType = resolveTargetType(target.type);
+      if (targetType !== expectedType) {
+        continue;
+      }
+      if (targetType === "archive") {
+        if (target.linkOptions !== void 0) {
+          throw new Error(
+            `linkOptions is not supported for archive target: ${targetName}`
+          );
+        }
+        if (target.exports !== void 0) {
+          throw new Error(
+            `exports is not supported for archive target: ${targetName}`
+          );
+        }
+      }
+      const mergedLinkOptions = targetType === "archive" ? [] : [
         ...ensureArray(common.linkOptions),
         ...ensureArray(target.linkOptions)
       ];
-      const mergedExports = [
-        ...ensureArray(common.exports),
-        ...ensureArray(target.exports)
-      ];
+      const mergedExports = targetType === "archive" ? [] : [...ensureArray(common.exports), ...ensureArray(target.exports)];
       const baseCompileOptions = [
         ...ensureArray(common.options),
         ...ensureArray(target.options)
       ];
       const baseIncludeDirs = [
-        ...ensureArray(common.includeDirs),
-        ...ensureArray(target.includeDirs)
+        ...ensureArray(commonIncludeDirs),
+        ...ensureArray(target.includeDirs),
+        ...importIncludeDirs
       ];
       const baseDefines = mergeDefines(common.defines, target.defines);
-      const sourceGroups = (_i = target.sourceGroups) != null ? _i : [];
+      const sourceGroups = (_a2 = target.sourceGroups) != null ? _a2 : [];
       const targetEnv = {
         ...envWithDirs,
         TARGET_NAME: targetName
@@ -716,7 +932,8 @@ const buildWasm = async (options) => {
         targetName,
         target.outFile,
         targetEnv,
-        outDir
+        targetType === "archive" ? libDir : outDir,
+        targetType === "archive" ? "a" : "wasm"
       );
       const sources = await resolveTargetSources(
         target.sources,
@@ -752,12 +969,8 @@ const buildWasm = async (options) => {
       const targetBuildDir = path.resolve(buildRunDir, targetName);
       await promises.rm(targetBuildDir, { recursive: true, force: true });
       await ensureDirectory(targetBuildDir);
-      const resolvedLinkOptions = expandArray(
-        mergedLinkOptions,
-        targetEnv,
-        "linkOptions"
-      );
-      const resolvedExports = expandArray(mergedExports, targetEnv, "exports");
+      const resolvedLinkOptions = targetType === "archive" ? [] : expandArray(mergedLinkOptions, targetEnv, "linkOptions");
+      const resolvedExports = targetType === "archive" ? [] : expandArray(mergedExports, targetEnv, "exports");
       const exportArgs = buildExportFlags(resolvedExports);
       const baseCompileArgs = buildCompileArgs(
         baseCompileOptions,
@@ -767,7 +980,7 @@ const buildWasm = async (options) => {
         rootDir
       );
       const groupCompileArgs = sourceGroups.map((group) => {
-        var _a2;
+        var _a3;
         const groupOptions = [
           ...baseCompileOptions,
           ...ensureArray(group == null ? void 0 : group.options)
@@ -776,7 +989,7 @@ const buildWasm = async (options) => {
           ...baseIncludeDirs,
           ...ensureArray(group == null ? void 0 : group.includeDirs)
         ];
-        const groupDefines = mergeDefines(baseDefines, (_a2 = group == null ? void 0 : group.defines) != null ? _a2 : {});
+        const groupDefines = mergeDefines(baseDefines, (_a3 = group == null ? void 0 : group.defines) != null ? _a3 : {});
         return buildCompileArgs(
           groupOptions,
           groupIncludeDirs,
@@ -785,7 +998,6 @@ const buildWasm = async (options) => {
           rootDir
         );
       });
-      logger.info(`Compiling target: ${targetName}`);
       const compileSource = async (source, args, groupIndex) => {
         const objectName = toSafeObjectName(rootDir, source, groupIndex);
         const outputObject = path.resolve(targetBuildDir, `${objectName}.o`);
@@ -798,6 +1010,8 @@ const buildWasm = async (options) => {
           ...args.includeArgs,
           ...args.defineArgs
         ];
+        const sourcePath = path.relative(rootDir, source);
+        logger.info(`Compiling source: ${sourcePath} --> $tmp/${objectName}.o`);
         logger.debug(`emcc ${compileArgs.join(" ")}`);
         await runCommandWithEnv(
           emccCommand,
@@ -838,6 +1052,9 @@ const buildWasm = async (options) => {
           groupIndex: void 0
         });
       }
+      logger.info(
+        parallel ? `Building target: '${targetName}' [${compileJobs.length} files, in parallel]` : `Building target: '${targetName}' [${compileJobs.length} files]`
+      );
       for (let index = 0; index < groupSources.length; index += 1) {
         const sourcesInGroup = groupSources[index];
         if (!sourcesInGroup) {
@@ -856,24 +1073,45 @@ const buildWasm = async (options) => {
           (job) => compileSource(job.source, job.args, job.groupIndex)
         )
       ) : await buildObjectsSequential();
-      logger.info(`Linking target: ${targetName}`);
-      const linkArgs = [
-        ...objectFiles,
-        "-o",
-        resolvedOutFile,
-        ...resolvedLinkOptions,
-        ...exportArgs
-      ];
-      logger.debug(`emcc ${linkArgs.join(" ")}`);
-      await runCommandWithEnv(
-        emccCommand,
-        linkArgs,
-        rootDir,
-        buildEnv,
-        emsdkOptions.signal
-      );
+      if (targetType === "archive") {
+        if (!emarCommand) {
+          throw new Error("emar command is required for archive targets.");
+        }
+        logger.info(`Archiving target: ${targetName}.a`);
+        const archiveArgs = ["rcs", resolvedOutFile, ...objectFiles];
+        logger.debug(`emar ${archiveArgs.join(" ")}`);
+        await runCommandWithEnv(
+          emarCommand,
+          archiveArgs,
+          rootDir,
+          buildEnv,
+          emsdkOptions.signal
+        );
+      } else {
+        logger.info(`Linking target: ${targetName}.wasm`);
+        const linkArgs = [
+          ...objectFiles,
+          "-o",
+          resolvedOutFile,
+          ...linkLibDirs.map((dir) => `-L${dir}`),
+          ...resolvedLinkOptions,
+          ...exportArgs
+        ];
+        logger.debug(`emcc ${linkArgs.join(" ")}`);
+        await runCommandWithEnv(
+          emccCommand,
+          linkArgs,
+          rootDir,
+          buildEnv,
+          emsdkOptions.signal
+        );
+      }
       outFiles[targetName] = resolvedOutFile;
     }
+  };
+  try {
+    await buildTargets("archive");
+    await buildTargets("wasm");
   } finally {
     if (cleanupBuildDir) {
       await promises.rm(buildRunDir, { recursive: true, force: true });
@@ -885,5 +1123,6 @@ const buildWasm = async (options) => {
   };
 };
 exports.buildWasm = buildWasm;
+exports.createConsoleLogger = createConsoleLogger;
 exports.prepareEmsdk = prepareEmsdk;
-//# sourceMappingURL=build-DdEthYh8.cjs.map
+//# sourceMappingURL=build-Djw1ummW.cjs.map