emsdk-env 0.3.0 → 0.5.0

package/dist/{build-CYHeaOdc.js → build-EqOBCaAv.js}

@@ -1,17 +1,17 @@
 /*!
  * 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
  */
 
-import { mkdir, access, constants, mkdtemp, rename, rm } from "fs/promises";
+import { mkdir, access, constants, mkdtemp, rename, rm, readFile } from "fs/promises";
 import { homedir, tmpdir } from "os";
 import { glob } from "glob";
-import { join, resolve, isAbsolute, relative } from "path";
+import { join, resolve, isAbsolute, dirname, relative } from "path";
 import { spawn } from "child_process";
 const __NOOP_HANDLER = () => {
 };
@@ -501,6 +501,22 @@ const resolveEmccCommand = async (env, emsdkRoot) => {
   }
   return "emcc";
 };
+const resolveEmarCommand = async (env, emsdkRoot) => {
+  if (env.EMAR) {
+    return env.EMAR;
+  }
+  if (env.EMSCRIPTEN) {
+    const candidate = join(env.EMSCRIPTEN, "emar");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  const fallback = join(emsdkRoot, "upstream", "emscripten", "emar");
+  if (await pathExists(fallback)) {
+    return fallback;
+  }
+  return "emar";
+};
 const createConsoleLogger = (prefix) => {
   return {
     debug: (msg) => console.debug(`[${prefix}]: ${msg}`),
@@ -510,7 +526,11 @@ const createConsoleLogger = (prefix) => {
   };
 };
 const DEFAULT_WASM_SRC_DIR = "wasm";
+const DEFAULT_WASM_INCLUDE_DIR = "include";
 const DEFAULT_WASM_OUT_DIR = 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 = join(tmpdir(), "emsdk-env");
 const DEFAULT_EMSDK_TARGET_VERSION = "latest";
 let buildSequence = 0;
@@ -531,6 +551,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 {
@@ -592,11 +613,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 resolve(outDir, `${targetName}.wasm`);
+  return resolve(baseDir, `${targetName}.${extension}`);
 };
 const resolveTargetSources = async (targetSources, env, srcDir) => {
   const patterns = targetSources && targetSources.length > 0 ? targetSources : [join(srcDir, "**", "*.c"), join(srcDir, "**", "*.cpp")];
@@ -621,6 +642,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 = dirname(startPath);
+  for (; ; ) {
+    const candidate = join(current, "package.json");
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+    const parent = 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 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 = 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 = resolve(packageRoot, includeRel);
+  const libDir = 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(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(
@@ -630,15 +763,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");
@@ -655,57 +788,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 = 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 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
@@ -715,7 +909,8 @@ const buildWasm = async (options) => {
         targetName,
         target.outFile,
         targetEnv,
-        outDir
+        targetType === "archive" ? libDir : outDir,
+        targetType === "archive" ? "a" : "wasm"
       );
       const sources = await resolveTargetSources(
         target.sources,
@@ -751,12 +946,8 @@ const buildWasm = async (options) => {
       const targetBuildDir = resolve(buildRunDir, targetName);
       await 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,
@@ -766,7 +957,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)
@@ -775,7 +966,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,
@@ -784,7 +975,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 = resolve(targetBuildDir, `${objectName}.o`);
@@ -797,6 +987,8 @@ const buildWasm = async (options) => {
           ...args.includeArgs,
           ...args.defineArgs
         ];
+        const sourcePath = relative(rootDir, source);
+        logger.info(`Compiling source: ${sourcePath} --> $tmp/${objectName}.o`);
         logger.debug(`emcc ${compileArgs.join(" ")}`);
         await runCommandWithEnv(
           emccCommand,
@@ -837,6 +1029,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) {
@@ -855,24 +1050,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 rm(buildRunDir, { recursive: true, force: true });
@@ -885,6 +1101,7 @@ const buildWasm = async (options) => {
 };
 export {
   buildWasm as b,
+  createConsoleLogger as c,
   prepareEmsdk as p
 };
-//# sourceMappingURL=build-CYHeaOdc.js.map
+//# sourceMappingURL=build-EqOBCaAv.js.map