smartbundle 0.5.4 → 0.7.0-alpha.0

package/__do_not_import_directly__/{copyStaticFiles.js → tasks/copyStaticFilesTask.js}

@@ -1,5 +1,12 @@
 import { join } from "node:path";
 import { readdir, copyFile } from "node:fs/promises";
+async function copyStaticFilesTask(sourceDir, outDir) {
+  return copyStaticFiles({
+    relativeFiles: /* @__PURE__ */ new Set(["readme.md"]),
+    sourceDir,
+    outDir
+  });
+}
 async function copyStaticFiles({
   sourceDir,
   outDir,
@@ -23,5 +30,5 @@ async function copyStaticFiles({
   }
 }
 export {
-  copyStaticFiles
+  copyStaticFilesTask
 };

package/__do_not_import_directly__/tasks/jsFilesTask.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("vite");
+const utils = require("./utils.cjs");
+async function jsFilesTask({
+  buildOutput,
+  entrypoints
+}) {
+  const reversedEntrypoints = utils.reverseMap(entrypoints);
+  const res = /* @__PURE__ */ new Map();
+  for (const el of buildOutput) {
+    if (el.facadeModuleId == null) {
+      continue;
+    }
+    const exportPath = reversedEntrypoints.get(el.facadeModuleId);
+    if (!exportPath) {
+      continue;
+    }
+    for (const path of exportPath) {
+      res.set(el.fileName, path);
+    }
+  }
+  return res;
+}
+exports.jsFilesTask = jsFilesTask;

package/__do_not_import_directly__/tasks/jsFilesTask.js

@@ -0,0 +1,25 @@
+import "vite";
+import { reverseMap } from "./utils.js";
+async function jsFilesTask({
+  buildOutput,
+  entrypoints
+}) {
+  const reversedEntrypoints = reverseMap(entrypoints);
+  const res = /* @__PURE__ */ new Map();
+  for (const el of buildOutput) {
+    if (el.facadeModuleId == null) {
+      continue;
+    }
+    const exportPath = reversedEntrypoints.get(el.facadeModuleId);
+    if (!exportPath) {
+      continue;
+    }
+    for (const path of exportPath) {
+      res.set(el.fileName, path);
+    }
+  }
+  return res;
+}
+export {
+  jsFilesTask
+};

package/__do_not_import_directly__/tasks/utils.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function reverseMap(map) {
+  const reversed = /* @__PURE__ */ new Map();
+  for (const [key, value] of map) {
+    const arr = reversed.get(value) ?? [];
+    arr.push(key);
+    reversed.set(value, arr);
+  }
+  return reversed;
+}
+exports.reverseMap = reverseMap;

package/__do_not_import_directly__/tasks/utils.js

@@ -0,0 +1,12 @@
+function reverseMap(map) {
+  const reversed = /* @__PURE__ */ new Map();
+  for (const [key, value] of map) {
+    const arr = reversed.get(value) ?? [];
+    arr.push(key);
+    reversed.set(value, arr);
+  }
+  return reversed;
+}
+export {
+  reverseMap
+};

package/__do_not_import_directly__/writePackageJson.cjs

@@ -1,13 +1,11 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const fs = require("node:fs/promises");
-async function writePackageJson(outDir, parsed, { exportsMap }) {
-  var _a;
+require("zod");
+require("node:path");
+async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const allExports = {};
   for (const [key, value] of exportsMap) {
-    if (key === "__bin__") {
-      continue;
-    }
     const anExport = {};
     if (value.dts) {
       anExport.types = value.dts;
@@ -30,12 +28,13 @@ async function writePackageJson(outDir, parsed, { exportsMap }) {
     allExports[key] = anExport;
   }
   allExports["./package.json"] = "./package.json";
+  const bin = binsMap.size > 0 ? Object.fromEntries(binsMap) : void 0;
   const rootExport = typeof allExports["."] === "object" ? allExports["."] : void 0;
   const res = {
     name: parsed.name,
     type: "module",
     version: parsed.version,
-    bin: (_a = exportsMap.get("__bin__")) == null ? void 0 : _a.mjs,
+    bin,
     types: rootExport == null ? void 0 : rootExport.types,
     module: rootExport == null ? void 0 : rootExport.default,
     description: parsed.description ?? "",

package/__do_not_import_directly__/writePackageJson.js

@@ -1,11 +1,9 @@
 import { writeFile } from "node:fs/promises";
-async function writePackageJson(outDir, parsed, { exportsMap }) {
-  var _a;
+import "zod";
+import "node:path";
+async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const allExports = {};
   for (const [key, value] of exportsMap) {
-    if (key === "__bin__") {
-      continue;
-    }
     const anExport = {};
     if (value.dts) {
       anExport.types = value.dts;
@@ -28,12 +26,13 @@ async function writePackageJson(outDir, parsed, { exportsMap }) {
     allExports[key] = anExport;
   }
   allExports["./package.json"] = "./package.json";
+  const bin = binsMap.size > 0 ? Object.fromEntries(binsMap) : void 0;
   const rootExport = typeof allExports["."] === "object" ? allExports["."] : void 0;
   const res = {
     name: parsed.name,
     type: "module",
     version: parsed.version,
-    bin: (_a = exportsMap.get("__bin__")) == null ? void 0 : _a.mjs,
+    bin,
     types: rootExport == null ? void 0 : rootExport.types,
     module: rootExport == null ? void 0 : rootExport.default,
     description: parsed.description ?? "",

package/__smartbundle__internals__/smartbundle

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import("../__do_not_import_directly__/smartbundle.js");

package/package.json

@@ -1,28 +1,30 @@
 {
   "name": "smartbundle",
   "type": "module",
-  "version": "0.5.4",
-  "bin": "./src/bin.js",
-  "types": "./src/run.d.ts",
-  "module": "./src/run.js",
+  "version": "0.7.0-alpha.0",
+  "bin": {
+    "smartbundle": "__smartbundle__internals__/smartbundle"
+  },
+  "types": "./src/index.d.ts",
+  "module": "./src/index.js",
   "description": "zero-config bundler for npm packages",
   "exports": {
     ".": {
-      "types": "./src/run.d.ts",
+      "types": "./src/index.d.ts",
       "import": {
-        "types": "./src/run.d.ts",
-        "default": "./src/run.js"
+        "types": "./src/index.d.ts",
+        "default": "./src/index.js"
       },
       "require": {
-        "types": "./src/run.d.ts",
-        "default": "./src/run.cjs"
+        "types": "./src/index.d.ts",
+        "default": "./src/index.cjs"
       },
-      "default": "./src/run.js"
+      "default": "./src/index.js"
     },
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "vite": "^5.3.4",
+    "vite": "^5.4.9",
     "yargs": "^17.7.2",
     "zod": "^3.23.8"
   },

package/src/buildVite.d.ts

@@ -1,4 +1,4 @@
-import { UserConfig } from "vite";
+import { type UserConfig } from "vite";
 import { Rollup } from "vite";
 type BuildViteOptions = {
     viteConfig: UserConfig;

package/src/createViteConfig.d.ts

@@ -7,5 +7,6 @@ type CreateViteConfigParam = {
 export declare function createViteConfig({ dirs, packageJson }: CreateViteConfigParam): {
     viteConfig: import("vite").UserConfig;
     entrypoints: Map<string, string>;
+    bins: Map<string, string>;
 };
 export {};

package/src/error.d.ts

@@ -0,0 +1,4 @@
+export declare class BuildError extends Error {
+    error: string;
+    constructor(error: string);
+}

package/src/errors.d.ts

@@ -9,7 +9,7 @@ export declare const errors: {
     privateIsTrue: string;
     descriptionString: string;
     dependenciesInvalid: string;
-    binString: string;
+    binFiled: string;
     rollupError: string;
     typescriptNotFound: string;
     optionalDependenciesInvalid: string;

package/src/index.cjs

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const path = require("node:path");
+const fs = require("node:fs/promises");
+const packageJson = require("../__do_not_import_directly__/packageJson.cjs");
+const writePackageJson = require("../__do_not_import_directly__/writePackageJson.cjs");
+const buildVite = require("../__do_not_import_directly__/buildVite.cjs");
+const resolveDirs = require("../__do_not_import_directly__/resolveDirs.cjs");
+const createViteConfig = require("../__do_not_import_directly__/createViteConfig.cjs");
+const copyStaticFilesTask = require("../__do_not_import_directly__/tasks/copyStaticFilesTask.cjs");
+const buildTypesTask = require("../__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.cjs");
+const error = require("../__do_not_import_directly__/error.cjs");
+const jsFilesTask = require("../__do_not_import_directly__/tasks/jsFilesTask.cjs");
+const binsTask = require("../__do_not_import_directly__/tasks/binsTask.cjs");
+function setExports(exportsMap, exportName, mapFn) {
+  const entry = exportsMap.get(exportName) ?? {};
+  exportsMap.set(exportName, mapFn(entry));
+}
+async function defineViteConfig(args = {}) {
+  const dirs = resolveDirs.resolveDirs(args);
+  const { sourceDir, outDir, packagePath, outInternalsDir } = dirs;
+  await fs.rm(outDir, { recursive: true, force: true });
+  await fs.mkdir(outDir, { recursive: true });
+  await fs.mkdir(outInternalsDir, { recursive: true });
+  const packageJson$1 = await packageJson.parsePackageJson({ sourceDir, packagePath });
+  if (Array.isArray(packageJson$1)) {
+    console.error(packageJson$1);
+    throw new Error("Failed to parse package.json");
+  }
+  const { viteConfig } = createViteConfig.createViteConfig({ dirs, packageJson: packageJson$1 });
+  return viteConfig;
+}
+async function run(args) {
+  const dirs = resolveDirs.resolveDirs(args);
+  const { sourceDir, outDir, packagePath, outInternalsDir } = dirs;
+  await fs.rm(outDir, { recursive: true, force: true });
+  await fs.mkdir(outDir, { recursive: true });
+  const packageJson$1 = await packageJson.parsePackageJson({ sourceDir, packagePath });
+  if (Array.isArray(packageJson$1)) {
+    console.log(packageJson$1);
+    return { error: true, errors: packageJson$1 };
+  }
+  const { viteConfig, entrypoints, bins } = createViteConfig.createViteConfig({
+    dirs,
+    packageJson: packageJson$1
+  });
+  const outputs = await buildVite.buildVite({ viteConfig });
+  if (outputs.error) {
+    return { error: true, errors: outputs.errors };
+  }
+  await fs.mkdir(outInternalsDir, { recursive: true });
+  const viteOutput = outputs.output;
+  const exportsMap = /* @__PURE__ */ new Map();
+  const binsMap = /* @__PURE__ */ new Map();
+  const tasksRes = await Promise.allSettled([
+    copyStaticFilesTask.copyStaticFilesTask(sourceDir, outDir),
+    buildTypesTask.buildTypesTask({
+      sourceDir,
+      outDir,
+      entrypoints,
+      buildOutput: viteOutput
+    }).then((res) => {
+      for (const [value, key] of res) {
+        setExports(exportsMap, key, (entry) => {
+          entry.dts = "./" + path.relative(outDir, value);
+          return entry;
+        });
+      }
+    }),
+    jsFilesTask.jsFilesTask({ buildOutput: viteOutput, entrypoints }).then((res) => {
+      for (const [value, key] of res) {
+        setExports(exportsMap, key, (entry) => {
+          const format = value.endsWith(".cjs") ? "cjs" : "es";
+          if (format === "es") {
+            entry.mjs = "./" + value;
+          } else if (format === "cjs") {
+            entry.cjs = "./" + value;
+          }
+          return entry;
+        });
+      }
+    }),
+    binsTask.binsTask({ outInternalsDir, bins, buildOutput: viteOutput, outDir }).then(
+      (res) => {
+        for (const [value, key] of res) {
+          binsMap.set(key, value);
+        }
+      }
+    )
+  ]);
+  const errors = tasksRes.filter((res) => res.status === "rejected").map((res) => res.reason).filter((res) => res instanceof error.BuildError).map((res) => res.error);
+  if (errors.length > 0) {
+    return { error: true, errors };
+  }
+  await writePackageJson.writePackageJson(outDir, packageJson$1, {
+    exportsMap,
+    binsMap
+  });
+  return { error: false };
+}
+exports.defineViteConfig = defineViteConfig;
+exports.run = run;

package/src/index.js

@@ -0,0 +1,102 @@
+import { relative } from "node:path";
+import { rm, mkdir } from "node:fs/promises";
+import { parsePackageJson } from "../__do_not_import_directly__/packageJson.js";
+import { writePackageJson } from "../__do_not_import_directly__/writePackageJson.js";
+import { buildVite } from "../__do_not_import_directly__/buildVite.js";
+import { resolveDirs } from "../__do_not_import_directly__/resolveDirs.js";
+import { createViteConfig } from "../__do_not_import_directly__/createViteConfig.js";
+import { copyStaticFilesTask } from "../__do_not_import_directly__/tasks/copyStaticFilesTask.js";
+import { buildTypesTask } from "../__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.js";
+import { BuildError } from "../__do_not_import_directly__/error.js";
+import { jsFilesTask } from "../__do_not_import_directly__/tasks/jsFilesTask.js";
+import { binsTask } from "../__do_not_import_directly__/tasks/binsTask.js";
+function setExports(exportsMap, exportName, mapFn) {
+  const entry = exportsMap.get(exportName) ?? {};
+  exportsMap.set(exportName, mapFn(entry));
+}
+async function defineViteConfig(args = {}) {
+  const dirs = resolveDirs(args);
+  const { sourceDir, outDir, packagePath, outInternalsDir } = dirs;
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+  await mkdir(outInternalsDir, { recursive: true });
+  const packageJson = await parsePackageJson({ sourceDir, packagePath });
+  if (Array.isArray(packageJson)) {
+    console.error(packageJson);
+    throw new Error("Failed to parse package.json");
+  }
+  const { viteConfig } = createViteConfig({ dirs, packageJson });
+  return viteConfig;
+}
+async function run(args) {
+  const dirs = resolveDirs(args);
+  const { sourceDir, outDir, packagePath, outInternalsDir } = dirs;
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { recursive: true });
+  const packageJson = await parsePackageJson({ sourceDir, packagePath });
+  if (Array.isArray(packageJson)) {
+    console.log(packageJson);
+    return { error: true, errors: packageJson };
+  }
+  const { viteConfig, entrypoints, bins } = createViteConfig({
+    dirs,
+    packageJson
+  });
+  const outputs = await buildVite({ viteConfig });
+  if (outputs.error) {
+    return { error: true, errors: outputs.errors };
+  }
+  await mkdir(outInternalsDir, { recursive: true });
+  const viteOutput = outputs.output;
+  const exportsMap = /* @__PURE__ */ new Map();
+  const binsMap = /* @__PURE__ */ new Map();
+  const tasksRes = await Promise.allSettled([
+    copyStaticFilesTask(sourceDir, outDir),
+    buildTypesTask({
+      sourceDir,
+      outDir,
+      entrypoints,
+      buildOutput: viteOutput
+    }).then((res) => {
+      for (const [value, key] of res) {
+        setExports(exportsMap, key, (entry) => {
+          entry.dts = "./" + relative(outDir, value);
+          return entry;
+        });
+      }
+    }),
+    jsFilesTask({ buildOutput: viteOutput, entrypoints }).then((res) => {
+      for (const [value, key] of res) {
+        setExports(exportsMap, key, (entry) => {
+          const format = value.endsWith(".cjs") ? "cjs" : "es";
+          if (format === "es") {
+            entry.mjs = "./" + value;
+          } else if (format === "cjs") {
+            entry.cjs = "./" + value;
+          }
+          return entry;
+        });
+      }
+    }),
+    binsTask({ outInternalsDir, bins, buildOutput: viteOutput, outDir }).then(
+      (res) => {
+        for (const [value, key] of res) {
+          binsMap.set(key, value);
+        }
+      }
+    )
+  ]);
+  const errors = tasksRes.filter((res) => res.status === "rejected").map((res) => res.reason).filter((res) => res instanceof BuildError).map((res) => res.error);
+  if (errors.length > 0) {
+    return { error: true, errors };
+  }
+  await writePackageJson(outDir, packageJson, {
+    exportsMap,
+    binsMap
+  });
+  return { error: false };
+}
+export {
+  defineViteConfig,
+  run
+};

package/src/packageJson.d.ts

@@ -1,13 +1,13 @@
 import z from "zod";
 declare function createPackageJsonSchema(sourceDir: string): z.ZodObject<{
-    exports: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    exports: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodString, Map<string, string>, string>, z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<string, string>, Record<string, string>>]>, Map<string, string>, string | Record<string, string>>>;
     name: z.ZodEffects<z.ZodString, string, string>;
     version: z.ZodString;
     private: z.ZodEffects<z.ZodBoolean, boolean, boolean>;
     description: z.ZodOptional<z.ZodString>;
     dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     optionalDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    bin: z.ZodOptional<z.ZodString>;
+    bin: z.ZodOptional<z.ZodEffects<z.ZodUnion<[z.ZodEffects<z.ZodString, Map<string, string>, string>, z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodString>, Map<string, string>, Record<string, string>>]>, Map<string, string>, string | Record<string, string>>>;
     repository: z.ZodOptional<z.ZodAny>;
     keywords: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     author: z.ZodOptional<z.ZodAny>;
@@ -26,14 +26,14 @@ declare function createPackageJsonSchema(sourceDir: string): z.ZodObject<{
     unpkg: z.ZodOptional<z.ZodAny>;
     homepage: z.ZodOptional<z.ZodAny>;
 }, "strip", z.ZodTypeAny, {
-    exports?: string;
+    exports?: Map<string, string>;
     name?: string;
     version?: string;
     private?: boolean;
     description?: string;
     dependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
-    bin?: string;
+    bin?: Map<string, string>;
     repository?: any;
     keywords?: string[];
     author?: any;
@@ -52,14 +52,14 @@ declare function createPackageJsonSchema(sourceDir: string): z.ZodObject<{
     unpkg?: any;
     homepage?: any;
 }, {
-    exports?: string;
+    exports?: string | Record<string, string>;
     name?: string;
     version?: string;
     private?: boolean;
     description?: string;
     dependencies?: Record<string, string>;
     optionalDependencies?: Record<string, string>;
-    bin?: string;
+    bin?: string | Record<string, string>;
     repository?: any;
     keywords?: string[];
     author?: any;

package/src/resolveDirs.d.ts

@@ -7,5 +7,6 @@ export declare function resolveDirs(args: Args): {
     sourceDir: string;
     packagePath: string;
     outDir: string;
+    outInternalsDir: string;
 };
 export type Dirs = ReturnType<typeof resolveDirs>;

package/src/tasks/binsTask.d.ts

@@ -0,0 +1,9 @@
+import { type Rollup } from "vite";
+type BinsTaskOption = {
+    buildOutput: Rollup.OutputChunk[];
+    bins: Map<string, string>;
+    outInternalsDir: string;
+    outDir: string;
+};
+export declare function binsTask({ buildOutput, bins, outInternalsDir, outDir, }: BinsTaskOption): Promise<Map<string, string>>;
+export {};

package/src/tasks/buildTypesTask/buildTypesTask.d.ts

@@ -0,0 +1,9 @@
+import { type Rollup } from "vite";
+type BuildTypesTaskOption = {
+    buildOutput: Rollup.OutputChunk[];
+    entrypoints: Map<string, string>;
+    sourceDir: string;
+    outDir: string;
+};
+export declare function buildTypesTask({ buildOutput, entrypoints, sourceDir, outDir, }: BuildTypesTaskOption): Promise<Map<string, string>>;
+export {};

package/src/tasks/buildTypesTask/callTypescript.d.ts

@@ -0,0 +1,8 @@
+type BuildTypesOptions = {
+    ts: typeof import("typescript");
+    sourceDir: string;
+    files: string[];
+    outDir: string;
+};
+export declare function callTypescript({ ts, sourceDir, files, outDir, }: BuildTypesOptions): Promise<Map<string, string>>;
+export {};

package/src/tasks/copyStaticFilesTask.d.ts

@@ -0,0 +1 @@
+export declare function copyStaticFilesTask(sourceDir: string, outDir: string): Promise<void>;

package/src/tasks/jsFilesTask.d.ts

@@ -0,0 +1,7 @@
+import { type Rollup } from "vite";
+type JsFilesTaskOption = {
+    buildOutput: Rollup.OutputChunk[];
+    entrypoints: Map<string, string>;
+};
+export declare function jsFilesTask({ buildOutput, entrypoints, }: JsFilesTaskOption): Promise<Map<string, string>>;
+export {};

package/src/tasks/utils.d.ts

@@ -0,0 +1 @@
+export declare function reverseMap(map: Map<string, string>): Map<string, Array<string>>;

package/src/writePackageJson.d.ts

@@ -1,4 +1,4 @@
-import { PackageJson } from "./packageJson.js";
+import { type PackageJson } from "./packageJson.js";
 export type ExportsObject = {
     mjs?: string;
     dts?: string;
@@ -7,6 +7,7 @@ export type ExportsObject = {
 };
 type BuildResult = {
     exportsMap: Map<string, ExportsObject>;
+    binsMap: Map<string, string>;
 };
-export declare function writePackageJson(outDir: string, parsed: PackageJson, { exportsMap }: BuildResult): Promise<void>;
+export declare function writePackageJson(outDir: string, parsed: PackageJson, { exportsMap, binsMap }: BuildResult): Promise<void>;
 export {};