smartbundle 0.1.0 → 0.2.0

package/__do_not_import_directly__/args.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const yargs = require("yargs");
+const process = require("node:process");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const process__namespace = /* @__PURE__ */ _interopNamespaceDefault(process);
+const args = yargs(process__namespace.argv.slice(2)).option("sourceDir", {
+  alias: "s",
+  type: "string",
+  describe: "path to the project directory. Default: current working directory"
+}).option("packagePath", {
+  alias: "p",
+  type: "string",
+  describe: "path to the package.json. Default: cwd()/package.json"
+}).option("outputDir", {
+  alias: "o",
+  type: "string",
+  describe: "path to the output directory. Default: cwd()/dist"
+}).help("help").parseSync();
+exports.args = args;

package/__do_not_import_directly__/errors.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const errors = {
+  exportsRequired: "The `exports` field is string. Please, verify the value. More info: https://nodejs.org/api/packages.html#package-entry-points",
+  exportsInvalid: "The `exports` field must be a path to entrypoint. Please, verify the value. More info: https://nodejs.org/api/packages.html#package-entry-points",
+  nameRequired: "The `name` field is required string. Please, verify the value. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#name",
+  nameMinLength: 'Min length of "name" is 1 character. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#name',
+  nameMaxLength: 'Max length of "name" is 214 characters. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#name',
+  nameStartsIllegalChars: "Name cannot start with `_` or `.` if it is not a scoped package. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#name",
+  versionRequired: "The `version` field is required string. Please, verify the value. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#version",
+  privateIsTrue: "The `private` field must be `true` for avoiding accidental publish. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#private",
+  descriptionString: "The `description` field must be a string. Please, verify the value. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#description",
+  dependenciesInvalid: "The `dependencies` field must be an Object<string, string>. Please, verify the value. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#dependencies",
+  binString: "The `bin` field must be a string. Please, verify the value. More info: https://docs.npmjs.com/cli/v10/configuring-npm/package-json#bin",
+  rollupError: "An error occurred while building the package. Please, report it to the issues on GitHub"
+};
+exports.errors = errors;

package/__do_not_import_directly__/index.cjs

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_path = require("node:path");
+const fs = require("node:fs/promises");
+const packageJson = require("./packageJson.cjs");
+const vite = require("vite");
+const writePackageJson = require("./writePackageJson.cjs");
+const rollupts = require("@rollup/plugin-typescript");
+const errors = require("./errors.cjs");
+function myResolve(path1, path2) {
+  if (node_path.isAbsolute(path2)) {
+    return path2;
+  }
+  return node_path.join(path1, path2);
+}
+function mapToObject(map) {
+  const obj = {};
+  for (const [key, value] of map) {
+    obj[key] = value;
+  }
+  return obj;
+}
+function reverseMap(map) {
+  const reversed = /* @__PURE__ */ new Map();
+  for (const [key, value] of map) {
+    const noExtValue = value.replace(/\.[^.]+$/, "");
+    const arr = reversed.get(noExtValue) ?? [];
+    arr.push(key);
+    reversed.set(noExtValue, arr);
+  }
+  return reversed;
+}
+function setExports(exportsMap, exportName, mapFn) {
+  const entry = exportsMap.get(exportName) ?? {};
+  exportsMap.set(exportName, mapFn(entry));
+}
+async function run(args) {
+  var _a;
+  const sourceDir = myResolve(process.cwd(), args.sourceDir ?? ".");
+  const packagePath = myResolve(sourceDir, args.packagePath ?? "./package.json");
+  const outDir = myResolve(process.cwd(), args.outputDir ?? "./dist");
+  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 entrypoints = /* @__PURE__ */ new Map();
+  if (packageJson$1.exports) {
+    const mainEntry = node_path.join(sourceDir, packageJson$1.exports);
+    entrypoints.set(".", mainEntry);
+  }
+  if (packageJson$1.bin) {
+    const binEntry = node_path.join(sourceDir, packageJson$1.bin);
+    entrypoints.set("__bin__", binEntry);
+  }
+  const hasTs = [...entrypoints.values()].some((entry) => entry.endsWith(".ts"));
+  const typescript = hasTs ? (
+    // @ts-expect-error
+    rollupts({
+      compilerOptions: {
+        rootDir: sourceDir,
+        declaration: true,
+        emitDeclarationOnly: true,
+        declarationDir: outDir
+      }
+    })
+  ) : false;
+  const outputs = await vite.build({
+    publicDir: false,
+    build: {
+      outDir,
+      write: true,
+      minify: false,
+      emptyOutDir: true,
+      assetsInlineLimit: 0,
+      terserOptions: {
+        compress: false,
+        mangle: false
+      },
+      lib: {
+        entry: mapToObject(entrypoints),
+        formats: ["es", "cjs"],
+        fileName: (format, entryName) => {
+          const entrypoint = entrypoints.get(entryName);
+          if (!entrypoint) {
+            const noExt2 = entryName.replace(/\.[^.]+$/, "");
+            return "__do_not_import_directly__/" + noExt2 + (format === "es" ? ".js" : ".cjs");
+          }
+          const relativePath = node_path.relative(sourceDir, entrypoint);
+          const noExt = relativePath.replace(/\.[^.]+$/, "");
+          if (format === "es") {
+            return `${noExt}.js`;
+          }
+          if (format === "cjs") {
+            return `${noExt}.cjs`;
+          }
+          return noExt;
+        }
+      },
+      rollupOptions: {
+        plugins: [typescript],
+        external: (id, parentId, isResolved) => {
+          if (id === packageJson$1.name) {
+            return true;
+          }
+          if (id.startsWith("node:")) {
+            return true;
+          }
+          if (packageJson$1.dependencies) {
+            return id in packageJson$1.dependencies;
+          }
+          return false;
+        },
+        output: {
+          preserveModules: true
+        }
+      }
+    }
+  });
+  if (!Array.isArray(outputs)) {
+    return { error: true, errors: [errors.errors.rollupError] };
+  }
+  const exportsMap = /* @__PURE__ */ new Map();
+  const reversedEntrypoints = reverseMap(entrypoints);
+  for (const { output } of outputs) {
+    for (const el of output) {
+      switch (el.type) {
+        case "chunk":
+          const noExtPath = (_a = el.facadeModuleId) == null ? void 0 : _a.replace(/\.[^.]+$/, "");
+          if (noExtPath == null) {
+            continue;
+          }
+          const exportPath = reversedEntrypoints.get(noExtPath);
+          if (!exportPath) {
+            continue;
+          }
+          for (const path of exportPath) {
+            setExports(exportsMap, path, (entry) => {
+              const format = el.fileName.endsWith(".cjs") ? "cjs" : "es";
+              if (format === "es") {
+                entry.mjs = "./" + el.fileName;
+              } else if (format === "cjs") {
+                entry.cjs = "./" + el.fileName;
+              }
+              return entry;
+            });
+          }
+          break;
+        case "asset":
+          if (el.fileName.endsWith(".d.ts")) {
+            const noExtPath2 = node_path.join(sourceDir, el.fileName.replace(/\.d\.ts$/, ""));
+            const exportPath2 = reversedEntrypoints.get(noExtPath2);
+            if (!exportPath2) {
+              continue;
+            }
+            for (const path of exportPath2) {
+              setExports(exportsMap, path, (entry) => {
+                entry.mdts = "./" + el.fileName;
+                return entry;
+              });
+            }
+          }
+          break;
+      }
+    }
+  }
+  await writePackageJson.writePackageJson(outDir, packageJson$1, {
+    exportsMap
+  });
+  return { error: false };
+}
+exports.run = run;

package/__do_not_import_directly__/{index.mjs → index.js}

@@ -1,10 +1,10 @@
 import { join, relative, isAbsolute } from "node:path";
 import { rm, mkdir } from "node:fs/promises";
-import { parsePackageJson } from "./packageJson.mjs";
+import { parsePackageJson } from "./packageJson.js";
 import { build } from "vite";
-import { writePackageJson } from "./writePackageJson.mjs";
+import { writePackageJson } from "./writePackageJson.js";
 import rollupts from "@rollup/plugin-typescript";
-import { errors } from "./errors.mjs";
+import { errors } from "./errors.js";
 function myResolve(path1, path2) {
   if (isAbsolute(path2)) {
     return path2;
@@ -58,7 +58,9 @@ async function run(args) {
     // @ts-expect-error
     rollupts({
       compilerOptions: {
+        rootDir: sourceDir,
         declaration: true,
+        emitDeclarationOnly: true,
         declarationDir: outDir
       }
     })
@@ -77,17 +79,20 @@ async function run(args) {
       },
       lib: {
         entry: mapToObject(entrypoints),
-        formats: ["es"],
+        formats: ["es", "cjs"],
         fileName: (format, entryName) => {
           const entrypoint = entrypoints.get(entryName);
           if (!entrypoint) {
             const noExt2 = entryName.replace(/\.[^.]+$/, "");
-            return "__do_not_import_directly__/" + noExt2 + ".mjs";
+            return "__do_not_import_directly__/" + noExt2 + (format === "es" ? ".js" : ".cjs");
           }
           const relativePath = relative(sourceDir, entrypoint);
           const noExt = relativePath.replace(/\.[^.]+$/, "");
           if (format === "es") {
-            return `${noExt}.mjs`;
+            return `${noExt}.js`;
+          }
+          if (format === "cjs") {
+            return `${noExt}.cjs`;
           }
           return noExt;
         }
@@ -131,7 +136,12 @@ async function run(args) {
           }
           for (const path of exportPath) {
             setExports(exportsMap, path, (entry) => {
-              entry.mjs = "./" + el.fileName;
+              const format = el.fileName.endsWith(".cjs") ? "cjs" : "es";
+              if (format === "es") {
+                entry.mjs = "./" + el.fileName;
+              } else if (format === "cjs") {
+                entry.cjs = "./" + el.fileName;
+              }
               return entry;
             });
           }

package/__do_not_import_directly__/packageJson.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs/promises");
+const z = require("zod");
+const errors = require("./errors.cjs");
+const node_path = require("node:path");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+async function fileExists(filePath) {
+  try {
+    const stats = await fs__namespace.stat(filePath);
+    return stats.isFile();
+  } catch (error) {
+    return false;
+  }
+}
+function dependencies(errorText) {
+  return z.record(z.string({ message: errorText }), { message: errorText }).optional();
+}
+function createPackageJsonSchema(sourceDir) {
+  return z.object({
+    exports: z.string({ message: errors.errors.exportsRequired }).refine((exports2) => {
+      const mainFinalPath = node_path.join(sourceDir, exports2);
+      return fileExists(mainFinalPath);
+    }, errors.errors.exportsInvalid).optional(),
+    name: z.string({ message: errors.errors.nameRequired }).min(1, errors.errors.nameMinLength).max(214, errors.errors.nameMaxLength).refine((name) => ["_", "."].every((start) => !name.startsWith(start)), errors.errors.nameStartsIllegalChars),
+    version: z.string({ message: errors.errors.versionRequired }),
+    private: z.boolean({ message: errors.errors.privateIsTrue }).refine((value) => value, errors.errors.privateIsTrue),
+    description: z.string({ message: errors.errors.descriptionString }).optional(),
+    dependencies: dependencies(errors.errors.dependenciesInvalid),
+    bin: z.string({ message: errors.errors.binString }).optional()
+  });
+}
+async function parsePackageJson({ sourceDir, packagePath }) {
+  const packageString = await fs__namespace.readFile(packagePath, "utf-8");
+  const rawJson = JSON.parse(packageString);
+  const packageJsonSchema = createPackageJsonSchema(sourceDir);
+  const packageJson = await packageJsonSchema.safeParseAsync(rawJson);
+  if (!packageJson.success) {
+    return packageJson.error.errors.map((error) => error.message);
+  }
+  return packageJson.data;
+}
+exports.parsePackageJson = parsePackageJson;

package/__do_not_import_directly__/{packageJson.mjs → packageJson.js}

@@ -1,6 +1,6 @@
 import * as fs from "node:fs/promises";
 import z from "zod";
-import { errors } from "./errors.mjs";
+import { errors } from "./errors.js";
 import { join } from "node:path";
 async function fileExists(filePath) {
   try {

package/__do_not_import_directly__/writePackageJson.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs/promises");
+async function writePackageJson(outDir, parsed, { exportsMap }) {
+  var _a, _b, _c;
+  const allExports = {};
+  for (const [key, value] of exportsMap) {
+    if (key === "__bin__") {
+      continue;
+    }
+    const anExport = {};
+    if (value.mjs || value.mdts) {
+      anExport.import = {
+        types: value.mdts,
+        default: value.mjs
+      };
+    }
+    if (value.cjs || value.cdts) {
+      anExport.require = {
+        types: value.cdts,
+        default: value.cjs
+      };
+    }
+    anExport.types = value.mdts;
+    anExport.default = value.mjs;
+    allExports[key] = anExport;
+  }
+  const res = {
+    name: parsed.name,
+    type: "module",
+    version: parsed.version,
+    bin: (_a = exportsMap.get("__bin__")) == null ? void 0 : _a.mjs,
+    types: (_b = allExports["."]) == null ? void 0 : _b.types,
+    module: (_c = allExports["."]) == null ? void 0 : _c.default,
+    description: parsed.description ?? "",
+    exports: allExports,
+    dependencies: parsed.dependencies ?? void 0
+  };
+  await fs.writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
+}
+exports.writePackageJson = writePackageJson;

package/__do_not_import_directly__/{writePackageJson.mjs → writePackageJson.js}

@@ -6,15 +6,20 @@ async function writePackageJson(outDir, parsed, { exportsMap }) {
     if (key === "__bin__") {
       continue;
     }
-    const anExport = {
-      types: value.mdts
-    };
+    const anExport = {};
     if (value.mjs || value.mdts) {
       anExport.import = {
         types: value.mdts,
         default: value.mjs
       };
     }
+    if (value.cjs || value.cdts) {
+      anExport.require = {
+        types: value.cdts,
+        default: value.cjs
+      };
+    }
+    anExport.types = value.mdts;
     anExport.default = value.mjs;
     allExports[key] = anExport;
   }

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "smartbundle",
   "type": "module",
-  "version": "0.1.0",
-  "bin": "./src/bin.mjs",
+  "version": "0.2.0",
+  "bin": "./src/bin.js",
   "types": "./src/run.d.ts",
-  "module": "./src/run.mjs",
+  "module": "./src/run.js",
   "description": "",
   "exports": {
     ".": {
-      "types": "./src/run.d.ts",
       "import": {
         "types": "./src/run.d.ts",
-        "default": "./src/run.mjs"
+        "default": "./src/run.js"
+      },
+      "require": {
+        "default": "./src/run.cjs"
       },
-      "default": "./src/run.mjs"
+      "types": "./src/run.d.ts",
+      "default": "./src/run.js"
     }
   },
   "dependencies": {

package/src/bin.cjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+"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
+));
+import("smartbundle");

package/src/bin.js

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

package/src/fixtures/export-default/entrypoint.d.ts

@@ -0,0 +1,2 @@
+declare const _default: 1;
+export default _default;

package/src/run.cjs

@@ -0,0 +1,4 @@
+"use strict";
+const args = require("../__do_not_import_directly__/args.cjs");
+const index = require("../__do_not_import_directly__/index.cjs");
+index.run(args.args);

package/src/run.d.ts

@@ -1 +1 @@
-export declare function main(): void;
+export {};

package/src/run.js

@@ -0,0 +1,3 @@
+import { args } from "../__do_not_import_directly__/args.js";
+import { run } from "../__do_not_import_directly__/index.js";
+run(args);

package/src/writePackageJson.d.ts

@@ -2,6 +2,8 @@ import { PackageJson } from "./packageJson.js";
 export type ExportsObject = {
     mjs?: string;
     mdts?: string;
+    cjs?: string;
+    cdts?: string;
 };
 type BuildResult = {
     exportsMap: Map<string, ExportsObject>;

package/src/bin.mjs

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import("smartbundle").then(({ main }) => main());

package/src/run.mjs

@@ -1,8 +0,0 @@
-import { args } from "../__do_not_import_directly__/args.mjs";
-import { run } from "../__do_not_import_directly__/index.mjs";
-function main() {
-  run(args);
-}
-export {
-  main
-};