emsdk-env 0.2.0 → 0.3.0

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

@@ -1,11 +1,11 @@
 /*!
  * name: emsdk-env
- * version: 0.2.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: e7a4478d462904c71937847aef2de1f460ffc0d5
+ * git.commit.hash: 4a03739b8c88111950fa216a7c10c7bfd65ea239
  */
 
 import { mkdir, access, constants, mkdtemp, rename, rm } from "fs/promises";
@@ -530,7 +530,7 @@ const createBuildId = () => {
   const seq = String(buildSequence).padStart(4, "0");
   return `${timestamp}_${seq}_${process.pid}`;
 };
-const ensureArray = (value) => value ? [...value] : [];
+const ensureArray = (value) => value != null ? value : [];
 const normalizePrepareOptions = (options) => {
   const { targetVersion, ...rest } = options != null ? options : {};
   return {
@@ -570,9 +570,15 @@ const resolveOutFile = (outFile, env, outDir) => {
   const expanded = expandPlaceholders(outFile, env, "outFile");
   return resolvePath(outDir, expanded);
 };
-const resolveSourcePatterns = (patterns, env, srcDir) => {
-  const expanded = expandArray(patterns, env, "sources");
-  return expanded.map((value) => resolvePath(srcDir, value));
+const resolveSourcesFromPatterns = async (patterns, env, srcDir, label) => {
+  const expanded = expandArray(patterns, env, label);
+  const resolvedPatterns = expanded.map((value) => resolvePath(srcDir, value));
+  const results = await Promise.all(
+    resolvedPatterns.map((pattern) => glob(pattern, { nodir: true }))
+  );
+  const sources = results.flat();
+  sources.sort();
+  return sources;
 };
 const buildDefineFlags = (defines) => Object.entries(defines).map(([key, value]) => `-D${key}=${String(value)}`);
 const buildExportFlags = (exports$1) => {
@@ -594,17 +600,37 @@ const resolveTargetOutFile = (targetName, targetOutFile, env, outDir) => {
 };
 const resolveTargetSources = async (targetSources, env, srcDir) => {
   const patterns = targetSources && targetSources.length > 0 ? targetSources : [join(srcDir, "**", "*.c"), join(srcDir, "**", "*.cpp")];
-  const resolvedPatterns = resolveSourcePatterns(patterns, env, srcDir);
-  const results = await Promise.all(
-    resolvedPatterns.map((pattern) => glob(pattern, { nodir: true }))
+  return resolveSourcesFromPatterns(patterns, env, srcDir, "sources");
+};
+const toSafeObjectName = (rootDir, sourcePath, groupIndex) => {
+  const baseName = relative(rootDir, sourcePath).replace(/[\\/]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
+  if (groupIndex === void 0) {
+    return baseName;
+  }
+  return `${baseName}__g${groupIndex}`;
+};
+const dedupeSources = (sources) => {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const source of sources) {
+    if (seen.has(source)) {
+      continue;
+    }
+    seen.add(source);
+    deduped.push(source);
+  }
+  return deduped;
+};
+const buildCompileArgs = (options, includeDirs, defines, env, rootDir) => {
+  const resolvedOptions = expandArray(options, env, "options");
+  const includeArgs = resolveIncludeDirs(includeDirs, env, rootDir).map(
+    (dir) => `-I${dir}`
   );
-  const sources = results.flat();
-  sources.sort();
-  return sources;
+  const defineArgs = buildDefineFlags(resolveDefines(defines, env));
+  return { resolvedOptions, includeArgs, defineArgs };
 };
-const toSafeObjectName = (rootDir, sourcePath) => relative(rootDir, sourcePath).replace(/[\\/]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_");
 const buildWasm = async (options) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   if (!options) {
     throw new TypeError("options must be provided.");
   }
@@ -662,10 +688,6 @@ const buildWasm = async (options) => {
   const outFiles = {};
   try {
     for (const [targetName, target] of targets) {
-      const mergedOptions = [
-        ...ensureArray(common.options),
-        ...ensureArray(target.options)
-      ];
       const mergedLinkOptions = [
         ...ensureArray(common.linkOptions),
         ...ensureArray(target.linkOptions)
@@ -674,11 +696,16 @@ const buildWasm = async (options) => {
         ...ensureArray(common.exports),
         ...ensureArray(target.exports)
       ];
-      const mergedIncludeDirs = [
+      const baseCompileOptions = [
+        ...ensureArray(common.options),
+        ...ensureArray(target.options)
+      ];
+      const baseIncludeDirs = [
         ...ensureArray(common.includeDirs),
         ...ensureArray(target.includeDirs)
       ];
-      const mergedDefines = mergeDefines(common.defines, target.defines);
+      const baseDefines = mergeDefines(common.defines, target.defines);
+      const sourceGroups = (_i = target.sourceGroups) != null ? _i : [];
       const targetEnv = {
         ...envWithDirs,
         TARGET_NAME: targetName
@@ -695,13 +722,35 @@ const buildWasm = async (options) => {
         targetEnv,
         srcDir
       );
-      if (sources.length === 0) {
+      const groupSources = sourceGroups.map(() => []);
+      const groupSourceSet = /* @__PURE__ */ new Set();
+      for (let index = 0; index < sourceGroups.length; index += 1) {
+        const group = sourceGroups[index];
+        if (!group) {
+          continue;
+        }
+        const resolved = await resolveSourcesFromPatterns(
+          group.sources,
+          targetEnv,
+          srcDir,
+          `sourceGroups[${index}].sources`
+        );
+        const deduped = dedupeSources(resolved);
+        groupSources[index] = deduped;
+        for (const source of deduped) {
+          groupSourceSet.add(source);
+        }
+      }
+      const baseSources = sources.filter(
+        (source) => !groupSourceSet.has(source)
+      );
+      const groupedSources = groupSources.flat();
+      if (baseSources.length + groupedSources.length === 0) {
         throw new Error(`No sources matched for target: ${targetName}`);
       }
       const targetBuildDir = resolve(buildRunDir, targetName);
       await rm(targetBuildDir, { recursive: true, force: true });
       await ensureDirectory(targetBuildDir);
-      const resolvedOptions = expandArray(mergedOptions, targetEnv, "options");
       const resolvedLinkOptions = expandArray(
         mergedLinkOptions,
         targetEnv,
@@ -709,31 +758,49 @@ const buildWasm = async (options) => {
       );
       const resolvedExports = expandArray(mergedExports, targetEnv, "exports");
       const exportArgs = buildExportFlags(resolvedExports);
-      const includeArgs = resolveIncludeDirs(
-        mergedIncludeDirs,
+      const baseCompileArgs = buildCompileArgs(
+        baseCompileOptions,
+        baseIncludeDirs,
+        baseDefines,
         targetEnv,
         rootDir
-      ).map((dir) => `-I${dir}`);
-      const defineArgs = buildDefineFlags(
-        resolveDefines(mergedDefines, targetEnv)
       );
+      const groupCompileArgs = sourceGroups.map((group) => {
+        var _a2;
+        const groupOptions = [
+          ...baseCompileOptions,
+          ...ensureArray(group == null ? void 0 : group.options)
+        ];
+        const groupIncludeDirs = [
+          ...baseIncludeDirs,
+          ...ensureArray(group == null ? void 0 : group.includeDirs)
+        ];
+        const groupDefines = mergeDefines(baseDefines, (_a2 = group == null ? void 0 : group.defines) != null ? _a2 : {});
+        return buildCompileArgs(
+          groupOptions,
+          groupIncludeDirs,
+          groupDefines,
+          targetEnv,
+          rootDir
+        );
+      });
       logger.info(`Compiling target: ${targetName}`);
-      const compileSource = async (source) => {
-        const objectName = toSafeObjectName(rootDir, source);
+      const compileSource = async (source, args, groupIndex) => {
+        const objectName = toSafeObjectName(rootDir, source, groupIndex);
         const outputObject = resolve(targetBuildDir, `${objectName}.o`);
-        const args = [
+        const compileArgs = [
           "-c",
           source,
           "-o",
           outputObject,
-          ...resolvedOptions,
-          ...includeArgs,
-          ...defineArgs
+          ...args.resolvedOptions,
+          ...args.includeArgs,
+          ...args.defineArgs
         ];
-        logger.debug(`emcc ${args.join(" ")}`);
+        logger.debug(`emcc ${compileArgs.join(" ")}`);
         await runCommandWithEnv(
           emccCommand,
-          args,
+          compileArgs,
           rootDir,
           buildEnv,
           emsdkOptions.signal
@@ -742,12 +809,52 @@ const buildWasm = async (options) => {
       };
       const buildObjectsSequential = async () => {
         const objectFiles2 = [];
-        for (const source of sources) {
-          objectFiles2.push(await compileSource(source));
+        for (const source of baseSources) {
+          objectFiles2.push(
+            await compileSource(source, baseCompileArgs, void 0)
+          );
+        }
+        for (let index = 0; index < groupSources.length; index += 1) {
+          const sourcesInGroup = groupSources[index];
+          if (!sourcesInGroup) {
+            continue;
+          }
+          const groupArgs = groupCompileArgs[index];
+          if (!groupArgs) {
+            continue;
+          }
+          for (const source of sourcesInGroup) {
+            objectFiles2.push(await compileSource(source, groupArgs, index));
+          }
         }
         return objectFiles2;
       };
-      const objectFiles = parallel ? await Promise.all(sources.map((source) => compileSource(source))) : await buildObjectsSequential();
+      const compileJobs = [];
+      for (const source of baseSources) {
+        compileJobs.push({
+          source,
+          args: baseCompileArgs,
+          groupIndex: void 0
+        });
+      }
+      for (let index = 0; index < groupSources.length; index += 1) {
+        const sourcesInGroup = groupSources[index];
+        if (!sourcesInGroup) {
+          continue;
+        }
+        const groupArgs = groupCompileArgs[index];
+        if (!groupArgs) {
+          continue;
+        }
+        for (const source of sourcesInGroup) {
+          compileJobs.push({ source, args: groupArgs, groupIndex: index });
+        }
+      }
+      const objectFiles = parallel ? await Promise.all(
+        compileJobs.map(
+          (job) => compileSource(job.source, job.args, job.groupIndex)
+        )
+      ) : await buildObjectsSequential();
       logger.info(`Linking target: ${targetName}`);
       const linkArgs = [
         ...objectFiles,
@@ -780,4 +887,4 @@ export {
   buildWasm as b,
   prepareEmsdk as p
 };
-//# sourceMappingURL=build-qp0IEBnb.js.map
+//# sourceMappingURL=build-CYHeaOdc.js.map