fix(conditions): merge specified conditions from option

src/conditions.ts

@@ -15,25 +15,27 @@ export function resolveKind(kind: ImportKind): string | null {
   }
 }
 
+export interface ResolveConditionsContext {
+  kind: ImportKind;
+  platform: Platform;
+}
+
 export function resolveConditions(
-  args: {
-    kind: ImportKind;
-    platform: Platform;
-    conditions?: string[];
-  },
+  conditions: string[] | undefined,
+  context: ResolveConditionsContext,
 ): string[] {
-  const conditions = new Set<string>();
-  const kind = resolveKind(args.kind);
+  const allConditions = new Set<string>(conditions);
+  const kind = resolveKind(context.kind);
 
-  if (typeof kind === "string") conditions.add(kind);
+  if (typeof kind === "string") allConditions.add(kind);
 
-  const platform = resolvePlatform(args.platform);
+  const platform = resolvePlatform(context.platform);
 
-  if (typeof platform === "string") conditions.add(platform);
+  if (typeof platform === "string") allConditions.add(platform);
 
-  if (args.conditions === undefined) conditions.add("module");
+  if (conditions === undefined) allConditions.add("module");
 
-  return [...conditions];
+  return [...allConditions];
 }
 
 export function resolvePlatform(platForm: Platform): string | null {

src/conditions_test.ts

@@ -0,0 +1,50 @@
+import {
+  resolveConditions,
+  type ResolveConditionsContext,
+} from "./conditions.ts";
+import { describe, it } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+
+describe("resolveConditions", () => {
+  it("if conditions is undefined", () => {
+    const table: [ResolveConditionsContext, string[]][] = [
+      [{
+        kind: "import-statement",
+        platform: "browser",
+      }, ["import", "browser", "module"]],
+      [{ kind: "require-call", platform: "browser" }, [
+        "require",
+        "browser",
+        "module",
+      ]],
+      [{ kind: "require-resolve", platform: "browser" }, ["browser", "module"]],
+      [{ kind: "require-resolve", platform: "neutral" }, ["module"]],
+      [{ kind: "require-resolve", platform: "node" }, ["node", "module"]],
+    ];
+
+    table.forEach(([context, expected]) => {
+      expect(
+        resolveConditions(undefined, context),
+      ).toEqual(expected);
+    });
+  });
+
+  it("if conditions is defined, the result does not includes module", () => {
+    const table: [string[], string[]][] = [
+      [[], ["import", "browser"]],
+      [["testing"], ["testing", "import", "browser"]],
+      [["module"], ["module", "import", "browser"]],
+      [["a", "a", "b", "b"], ["a", "b", "import", "browser"]],
+      [["import", "browser"], ["import", "browser"]],
+    ];
+
+    table.forEach(([conditions, expected]) => {
+      expect(
+        resolveConditions(conditions, {
+          kind: "import-statement",
+          platform: "browser",
+        }),
+      ).toEqual(expected);
+    });
+  });
+});

src/main_fields.ts

@@ -1,5 +1,4 @@
 import { type Platform } from "esbuild";
-import { normalizePlatform } from "./utils.ts";
 
 /**
  * @see https://esbuild.github.io/api/#platform
@@ -11,11 +10,10 @@ export const defaultMainFields = {
 } satisfies { [k in Platform]: string[] };
 
 export function resolveMainFields(
-  args: { platform?: Platform; mainFields?: string[] },
+  mainFields: string[] | undefined,
+  context: { platform: Platform },
 ): string[] {
-  if (args.mainFields) return args.mainFields;
+  if (mainFields) return mainFields;
 
-  const platform = normalizePlatform(args.platform);
-
-  return defaultMainFields[platform];
+  return defaultMainFields[context.platform];
 }

src/resolve.ts

@@ -185,17 +185,13 @@ export function createResolve(
     source: Source;
   },
 ) => Promise<OnResolveResult> {
-  const mainFields = resolveMainFields({
-    platform: buildOptions.platform,
-    mainFields: buildOptions.mainFields,
-  });
   const platform = normalizePlatform(buildOptions.platform);
+  const mainFields = resolveMainFields(buildOptions.mainFields, { platform });
 
   return (specifier, referrer, options, context) => {
-    const conditions = resolveConditions({
+    const conditions = resolveConditions(buildOptions.conditions, {
       kind: options.kind,
       platform,
-      conditions: buildOptions.conditions,
     });
 
     return resolve(specifier, referrer, {