smartbundle 0.0.1

package/__do_not_import_directly__/args.mjs

@@ -0,0 +1,18 @@
+import yargs from "yargs";
+import * as process from "node:process";
+const args = yargs(process.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();
+export {
+  args
+};

package/__do_not_import_directly__/errors.mjs

@@ -0,0 +1,17 @@
+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"
+};
+export {
+  errors
+};

package/__do_not_import_directly__/index.mjs

@@ -0,0 +1,161 @@
+import { join, relative, isAbsolute } from "node:path";
+import { rm, mkdir } from "node:fs/promises";
+import { parsePackageJson } from "./packageJson.mjs";
+import { build } from "vite";
+import { writePackageJson } from "./writePackageJson.mjs";
+import rollupts from "@rollup/plugin-typescript";
+import { errors } from "./errors.mjs";
+function myResolve(path1, path2) {
+  if (isAbsolute(path2)) {
+    return path2;
+  }
+  return 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 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 entrypoints = /* @__PURE__ */ new Map();
+  if (packageJson.exports) {
+    const mainEntry = join(sourceDir, packageJson.exports);
+    entrypoints.set(".", mainEntry);
+  }
+  if (packageJson.bin) {
+    const binEntry = join(sourceDir, packageJson.bin);
+    entrypoints.set("__bin__", binEntry);
+  }
+  const hasTs = [...entrypoints.values()].some((entry) => entry.endsWith(".ts"));
+  const typescript = hasTs ? (
+    // @ts-expect-error
+    rollupts({
+      compilerOptions: {
+        declaration: true,
+        declarationDir: outDir
+      }
+    })
+  ) : false;
+  const outputs = await build({
+    publicDir: false,
+    build: {
+      outDir,
+      write: true,
+      minify: false,
+      emptyOutDir: true,
+      assetsInlineLimit: 0,
+      terserOptions: {
+        compress: false,
+        mangle: false
+      },
+      lib: {
+        entry: mapToObject(entrypoints),
+        formats: ["es"],
+        fileName: (format, entryName) => {
+          const entrypoint = entrypoints.get(entryName);
+          if (!entrypoint) {
+            const noExt2 = entryName.replace(/\.[^.]+$/, "");
+            return "__do_not_import_directly__/" + noExt2 + ".mjs";
+          }
+          const relativePath = relative(sourceDir, entrypoint);
+          const noExt = relativePath.replace(/\.[^.]+$/, "");
+          if (format === "es") {
+            return `${noExt}.mjs`;
+          }
+          return noExt;
+        }
+      },
+      rollupOptions: {
+        plugins: [typescript],
+        external: (id, parentId, isResolved) => {
+          if (id.startsWith("node:")) {
+            return true;
+          }
+          if (packageJson.dependencies) {
+            return id in packageJson.dependencies;
+          }
+          return false;
+        },
+        output: {
+          preserveModules: true
+        }
+      }
+    }
+  });
+  if (!Array.isArray(outputs)) {
+    return { error: true, 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) => {
+              entry.mjs = "./" + el.fileName;
+              return entry;
+            });
+          }
+          break;
+        case "asset":
+          if (el.fileName.endsWith(".d.ts")) {
+            const noExtPath2 = 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(outDir, packageJson, {
+    exportsMap
+  });
+  return { error: false };
+}
+export {
+  run
+};

package/__do_not_import_directly__/packageJson.mjs

@@ -0,0 +1,41 @@
+import * as fs from "node:fs/promises";
+import z from "zod";
+import { errors } from "./errors.mjs";
+import { join } from "node:path";
+async function fileExists(filePath) {
+  try {
+    const stats = await fs.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.exportsRequired }).refine((exports) => {
+      const mainFinalPath = join(sourceDir, exports);
+      return fileExists(mainFinalPath);
+    }, errors.exportsInvalid).optional(),
+    name: z.string({ message: errors.nameRequired }).min(1, errors.nameMinLength).max(214, errors.nameMaxLength).refine((name) => ["_", "."].every((start) => !name.startsWith(start)), errors.nameStartsIllegalChars),
+    version: z.string({ message: errors.versionRequired }),
+    private: z.boolean({ message: errors.privateIsTrue }).refine((value) => value, errors.privateIsTrue),
+    description: z.string({ message: errors.descriptionString }).optional(),
+    dependencies: dependencies(errors.dependenciesInvalid),
+    bin: z.string({ message: errors.binString }).optional()
+  });
+}
+async function parsePackageJson({ sourceDir, packagePath }) {
+  const rawJson = (await import(packagePath)).default;
+  const packageJsonSchema = createPackageJsonSchema(sourceDir);
+  const packageJson = await packageJsonSchema.safeParseAsync(rawJson);
+  if (!packageJson.success) {
+    return packageJson.error.errors.map((error) => error.message);
+  }
+  return packageJson.data;
+}
+export {
+  parsePackageJson
+};

package/__do_not_import_directly__/writePackageJson.mjs

@@ -0,0 +1,36 @@
+import { writeFile } from "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 = {
+      types: value.mdts
+    };
+    if (value.mjs || value.mdts) {
+      anExport.import = {
+        types: value.mdts,
+        default: value.mjs
+      };
+    }
+    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 writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
+}
+export {
+  writePackageJson
+};

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "smartbundle",
+  "type": "module",
+  "version": "0.0.1",
+  "bin": "./src/bin.mjs",
+  "description": "",
+  "exports": {},
+  "dependencies": {
+    "@rollup/plugin-typescript": "^11.1.6",
+    "vite": "^5.3.4",
+    "yargs": "^17.7.2",
+    "zod": "^3.23.8"
+  }
+}

package/src/args.d.ts

@@ -0,0 +1,9 @@
+export declare const args: {
+    [x: string]: unknown;
+    sourceDir: string | undefined;
+    packagePath: string | undefined;
+    outputDir: string | undefined;
+    _: (string | number)[];
+    $0: string;
+};
+export type Args = typeof args;

package/src/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/src/bin.mjs

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

package/src/build.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/errors.d.ts

@@ -0,0 +1,14 @@
+export declare const errors: {
+    exportsRequired: string;
+    exportsInvalid: string;
+    nameRequired: string;
+    nameMinLength: string;
+    nameMaxLength: string;
+    nameStartsIllegalChars: string;
+    versionRequired: string;
+    privateIsTrue: string;
+    descriptionString: string;
+    dependenciesInvalid: string;
+    binString: string;
+    rollupError: string;
+};

package/src/fixtures/deep-structure/level1/dep1.d.ts

@@ -0,0 +1 @@
+export declare const a = 1;

package/src/fixtures/deep-structure/level1/level2/entrypoint1.d.ts

@@ -0,0 +1 @@
+export declare function foo(): void;

package/src/fixtures/simple-bin-build/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/src/fixtures/ts-import/a.d.ts

@@ -0,0 +1 @@
+export declare const a = 1;

package/src/fixtures/ts-import/entrypoint.d.ts

@@ -0,0 +1,2 @@
+export { a } from "./a.js";
+export declare function helloWorld(): void;

package/src/index.d.ts

@@ -0,0 +1,13 @@
+type Args = {
+    sourceDir?: string;
+    packagePath?: string;
+    outputDir?: string;
+};
+export declare function run(args: Args): Promise<{
+    error: boolean;
+    errors: string[];
+} | {
+    error: boolean;
+    errors?: undefined;
+}>;
+export {};

package/src/packageJson.d.ts

@@ -0,0 +1,35 @@
+import z from "zod";
+declare function createPackageJsonSchema(sourceDir: string): z.ZodObject<{
+    exports: z.ZodOptional<z.ZodEffects<z.ZodString, 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>>;
+    bin: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    private: boolean;
+    exports?: string | undefined;
+    description?: string | undefined;
+    dependencies?: Record<string, string> | undefined;
+    bin?: string | undefined;
+}, {
+    name: string;
+    version: string;
+    private: boolean;
+    exports?: string | undefined;
+    description?: string | undefined;
+    dependencies?: Record<string, string> | undefined;
+    bin?: string | undefined;
+}>;
+type PackageJsonSchema = ReturnType<typeof createPackageJsonSchema>;
+export type PackageJson = z.infer<PackageJsonSchema>;
+type Errors = Array<string>;
+type ParsePackageJsonArg = {
+    packagePath: string;
+    sourceDir: string;
+};
+export declare function parsePackageJson({ sourceDir, packagePath, }: ParsePackageJsonArg): Promise<PackageJson | Errors>;
+export {};

package/src/packageJson.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/writePackageJson.d.ts

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

package/types.d.ts

@@ -0,0 +1 @@
+import "vitest-directory-snapshot/dist/types.js";