smartbundle 0.7.3 → 0.8.0-alpha.1

package/__do_not_import_directly__/tasks/{utils.cjs → utils.mjs}

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 function reverseMap(map) {
   const reversed = /* @__PURE__ */ new Map();
   for (const [key, value] of map) {
@@ -9,4 +7,6 @@ function reverseMap(map) {
   }
   return reversed;
 }
-exports.reverseMap = reverseMap;
+export {
+  reverseMap
+};

package/__do_not_import_directly__/writePackageJson.js

@@ -1,13 +1,21 @@
-import { writeFile } from "node:fs/promises";
-import "zod";
-import "node:path";
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("node:fs/promises");
+require("zod");
+require("node:path");
+function extractValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.default;
+}
 async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const allExports = {};
   for (const [key, value] of exportsMap) {
     const anExport = {};
-    if (value.dts) {
-      anExport.types = value.dts;
-    }
     if (value.mjs) {
       anExport.import = {};
       if (value.dts) {
@@ -17,12 +25,13 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
     }
     if (value.cjs) {
       anExport.require = {};
-      if (value.dts) {
-        anExport.require.types = value.dts;
+      if (value.cdts) {
+        anExport.require.types = value.cdts;
       }
       anExport.require.default = value.cjs;
     }
-    anExport.default = value.mjs;
+    anExport.types = value.cdts ?? value.dts;
+    anExport.default = value.cjs;
     allExports[key] = anExport;
   }
   allExports["./package.json"] = "./package.json";
@@ -30,11 +39,12 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const rootExport = typeof allExports["."] === "object" ? allExports["."] : void 0;
   const res = {
     name: parsed.name,
-    type: "module",
+    type: "commonjs",
     version: parsed.version,
     bin,
     types: rootExport == null ? void 0 : rootExport.types,
-    module: rootExport == null ? void 0 : rootExport.default,
+    module: extractValue(rootExport == null ? void 0 : rootExport.import),
+    main: extractValue(rootExport == null ? void 0 : rootExport.require),
     description: parsed.description ?? "",
     exports: allExports,
     dependencies: parsed.dependencies ?? void 0,
@@ -57,8 +67,6 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
     homepage: parsed.homepage,
     devDependencies: parsed.devDependencies
   };
-  await writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
+  await fs.writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
 }
-export {
-  writePackageJson
-};
+exports.writePackageJson = writePackageJson;

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

@@ -1,15 +1,19 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const fs = require("node:fs/promises");
-require("zod");
-require("node:path");
+import { writeFile } from "node:fs/promises";
+import "zod";
+import "node:path";
+function extractValue(value) {
+  if (!value) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  return value.default;
+}
 async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const allExports = {};
   for (const [key, value] of exportsMap) {
     const anExport = {};
-    if (value.dts) {
-      anExport.types = value.dts;
-    }
     if (value.mjs) {
       anExport.import = {};
       if (value.dts) {
@@ -19,12 +23,13 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
     }
     if (value.cjs) {
       anExport.require = {};
-      if (value.dts) {
-        anExport.require.types = value.dts;
+      if (value.cdts) {
+        anExport.require.types = value.cdts;
       }
       anExport.require.default = value.cjs;
     }
-    anExport.default = value.mjs;
+    anExport.types = value.cdts ?? value.dts;
+    anExport.default = value.cjs;
     allExports[key] = anExport;
   }
   allExports["./package.json"] = "./package.json";
@@ -32,11 +37,12 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
   const rootExport = typeof allExports["."] === "object" ? allExports["."] : void 0;
   const res = {
     name: parsed.name,
-    type: "module",
+    type: "commonjs",
     version: parsed.version,
     bin,
     types: rootExport == null ? void 0 : rootExport.types,
-    module: rootExport == null ? void 0 : rootExport.default,
+    module: extractValue(rootExport == null ? void 0 : rootExport.import),
+    main: extractValue(rootExport == null ? void 0 : rootExport.require),
     description: parsed.description ?? "",
     exports: allExports,
     dependencies: parsed.dependencies ?? void 0,
@@ -59,6 +65,8 @@ async function writePackageJson(outDir, parsed, { exportsMap, binsMap }) {
     homepage: parsed.homepage,
     devDependencies: parsed.devDependencies
   };
-  await fs.writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
+  await writeFile(`${outDir}/package.json`, JSON.stringify(res, null, 2));
 }
-exports.writePackageJson = writePackageJson;
+export {
+  writePackageJson
+};

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "smartbundle",
-  "type": "module",
-  "version": "0.7.3",
+  "type": "commonjs",
+  "version": "0.8.0-alpha.1",
   "bin": {
     "smartbundle": "__bin__/smartbundle.js"
   },
-  "types": "./src/index.d.ts",
-  "module": "./src/index.js",
+  "types": "./src/index.d.cts",
+  "module": "./src/index.mjs",
+  "main": "./src/index.js",
   "description": "zero-config bundler for npm packages",
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
       "import": {
         "types": "./src/index.d.ts",
-        "default": "./src/index.js"
+        "default": "./src/index.mjs"
       },
       "require": {
-        "types": "./src/index.d.ts",
-        "default": "./src/index.cjs"
+        "types": "./src/index.d.cts",
+        "default": "./src/index.js"
       },
+      "types": "./src/index.d.cts",
       "default": "./src/index.js"
     },
     "./package.json": "./package.json"

package/src/args.d.cts

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

package/src/buildVite.d.cts

@@ -0,0 +1,16 @@
+import { type UserConfig } from "vite";
+import { Rollup } from "vite";
+type BuildViteOptions = {
+    viteConfig: UserConfig;
+};
+type BuildSuccess = {
+    error: false;
+    output: Rollup.OutputChunk[];
+};
+type BuildError = {
+    error: true;
+    errors: Array<string>;
+};
+type BuildResult = BuildSuccess | BuildError;
+export declare function buildVite({ viteConfig, }: BuildViteOptions): Promise<BuildResult>;
+export {};

package/src/createViteConfig.d.cts

@@ -0,0 +1,12 @@
+import { type Dirs } from "./resolveDirs.js";
+import { type PackageJson } from "./packageJson.js";
+type CreateViteConfigParam = {
+    dirs: Dirs;
+    packageJson: PackageJson;
+};
+export declare function createViteConfig({ dirs, packageJson }: CreateViteConfigParam): {
+    viteConfig: import("vite").UserConfig;
+    entrypoints: Map<string, string>;
+    bins: Map<string, string>;
+};
+export {};

package/src/error.d.cts

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

package/src/errors.d.cts

@@ -0,0 +1,28 @@
+export declare const errors: {
+    exportsRequired: string;
+    exportsInvalid: string;
+    nameRequired: string;
+    nameMinLength: string;
+    nameMaxLength: string;
+    nameStartsIllegalChars: string;
+    versionRequired: string;
+    privateIsTrue: string;
+    descriptionString: string;
+    dependenciesInvalid: string;
+    binFiled: string;
+    rollupError: string;
+    typescriptNotFound: string;
+    optionalDependenciesInvalid: string;
+    repositoryInvalid: string;
+    keywordsInvalid: string;
+    authorInvalid: string;
+    contributorsInvalid: string;
+    licenseInvalid: string;
+    devDependenciesInvalid: string;
+    peerDependenciesInvalid: string;
+    enginesInvalid: string;
+    browserInvalid: string;
+    fundingInvalid: string;
+    osInvalid: string;
+    cpuInvalid: string;
+};

package/src/index.d.cts

@@ -0,0 +1,9 @@
+import { type Args } from "./resolveDirs.js";
+export declare function defineViteConfig(args?: Args): Promise<import("vite").UserConfig>;
+export declare function run(args: Args): Promise<{
+    error: boolean;
+    errors: string[];
+} | {
+    error: boolean;
+    errors?: undefined;
+}>;

package/src/index.js

@@ -1,47 +1,49 @@
-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";
+"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.js");
+const writePackageJson = require("../__do_not_import_directly__/writePackageJson.js");
+const buildVite = require("../__do_not_import_directly__/buildVite.js");
+const resolveDirs = require("../__do_not_import_directly__/resolveDirs.js");
+const createViteConfig = require("../__do_not_import_directly__/createViteConfig.js");
+const copyStaticFilesTask = require("../__do_not_import_directly__/tasks/copyStaticFilesTask.js");
+const buildTypesTask = require("../__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.js");
+const error = require("../__do_not_import_directly__/error.js");
+const jsFilesTask = require("../__do_not_import_directly__/tasks/jsFilesTask.js");
+const binsTask = require("../__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 dirs = resolveDirs.resolveDirs(args);
   const { sourceDir, outDir, packagePath } = dirs;
-  await rm(outDir, { recursive: true, force: true });
-  await mkdir(outDir, { recursive: true });
-  const packageJson = await parsePackageJson({ sourceDir, packagePath });
-  if (Array.isArray(packageJson)) {
-    console.error(packageJson);
+  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.error(packageJson$1);
     throw new Error("Failed to parse package.json");
   }
-  const { viteConfig } = createViteConfig({ dirs, packageJson });
+  const { viteConfig } = createViteConfig.createViteConfig({ dirs, packageJson: packageJson$1 });
   return viteConfig;
 }
 async function run(args) {
-  const dirs = resolveDirs(args);
+  const dirs = resolveDirs.resolveDirs(args);
   const { sourceDir, outDir, packagePath, outBinsDir } = 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 };
+  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({
+  const { viteConfig, entrypoints, bins } = createViteConfig.createViteConfig({
     dirs,
-    packageJson
+    packageJson: packageJson$1
   });
-  const outputs = await buildVite({ viteConfig });
+  const outputs = await buildVite.buildVite({ viteConfig });
   if (outputs.error) {
     return { error: true, errors: outputs.errors };
   }
@@ -49,24 +51,29 @@ async function run(args) {
   const exportsMap = /* @__PURE__ */ new Map();
   const binsMap = /* @__PURE__ */ new Map();
   const tasksRes = await Promise.allSettled([
-    copyStaticFilesTask(sourceDir, outDir),
-    buildTypesTask({
+    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 = "./" + relative(outDir, value);
+      for (const [types, source] of res) {
+        setExports(exportsMap, source, (entry) => {
+          if (types.endsWith(".d.ts")) {
+            entry.dts = "./" + path.relative(outDir, types);
+          }
+          if (types.endsWith(".d.cts")) {
+            entry.cdts = "./" + path.relative(outDir, types);
+          }
           return entry;
         });
       }
     }),
-    jsFilesTask({ buildOutput: viteOutput, entrypoints }).then((res) => {
+    jsFilesTask.jsFilesTask({ buildOutput: viteOutput, entrypoints }).then((res) => {
       for (const [value, key] of res) {
         setExports(exportsMap, key, (entry) => {
-          const format = value.endsWith(".cjs") ? "cjs" : "es";
+          const format = value.endsWith(".js") ? "cjs" : "es";
           if (format === "es") {
             entry.mjs = "./" + value;
           } else if (format === "cjs") {
@@ -76,7 +83,7 @@ async function run(args) {
         });
       }
     }),
-    binsTask({ outBinsDir, bins, buildOutput: viteOutput, outDir }).then(
+    binsTask.binsTask({ outBinsDir, bins, buildOutput: viteOutput, outDir }).then(
       (res) => {
         for (const [value, key] of res) {
           binsMap.set(key, value);
@@ -84,17 +91,15 @@ async function run(args) {
       }
     )
   ]);
-  const errors = tasksRes.filter((res) => res.status === "rejected").map((res) => res.reason).filter((res) => res instanceof BuildError).map((res) => res.error);
+  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(outDir, packageJson, {
+  await writePackageJson.writePackageJson(outDir, packageJson$1, {
     exportsMap,
     binsMap
   });
   return { error: false };
 }
-export {
-  defineViteConfig,
-  run
-};
+exports.defineViteConfig = defineViteConfig;
+exports.run = run;

package/src/index.mjs

@@ -0,0 +1,105 @@
+import { relative } from "node:path";
+import { rm, mkdir } from "node:fs/promises";
+import { parsePackageJson } from "../__do_not_import_directly__/packageJson.mjs";
+import { writePackageJson } from "../__do_not_import_directly__/writePackageJson.mjs";
+import { buildVite } from "../__do_not_import_directly__/buildVite.mjs";
+import { resolveDirs } from "../__do_not_import_directly__/resolveDirs.mjs";
+import { createViteConfig } from "../__do_not_import_directly__/createViteConfig.mjs";
+import { copyStaticFilesTask } from "../__do_not_import_directly__/tasks/copyStaticFilesTask.mjs";
+import { buildTypesTask } from "../__do_not_import_directly__/tasks/buildTypesTask/buildTypesTask.mjs";
+import { BuildError } from "../__do_not_import_directly__/error.mjs";
+import { jsFilesTask } from "../__do_not_import_directly__/tasks/jsFilesTask.mjs";
+import { binsTask } from "../__do_not_import_directly__/tasks/binsTask.mjs";
+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 } = dirs;
+  await rm(outDir, { recursive: true, force: true });
+  await mkdir(outDir, { 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, outBinsDir } = 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 };
+  }
+  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 [types, source] of res) {
+        setExports(exportsMap, source, (entry) => {
+          if (types.endsWith(".d.ts")) {
+            entry.dts = "./" + relative(outDir, types);
+          }
+          if (types.endsWith(".d.cts")) {
+            entry.cdts = "./" + relative(outDir, types);
+          }
+          return entry;
+        });
+      }
+    }),
+    jsFilesTask({ buildOutput: viteOutput, entrypoints }).then((res) => {
+      for (const [value, key] of res) {
+        setExports(exportsMap, key, (entry) => {
+          const format = value.endsWith(".js") ? "cjs" : "es";
+          if (format === "es") {
+            entry.mjs = "./" + value;
+          } else if (format === "cjs") {
+            entry.cjs = "./" + value;
+          }
+          return entry;
+        });
+      }
+    }),
+    binsTask({ outBinsDir, 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.cts

@@ -0,0 +1,89 @@
+import z from "zod";
+declare function createPackageJsonSchema(sourceDir: string): z.ZodObject<{
+    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.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>;
+    maintainers: z.ZodOptional<z.ZodAny>;
+    contributors: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>]>, "many">>;
+    license: z.ZodOptional<z.ZodAny>;
+    devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    engines: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    browser: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>;
+    bugs: z.ZodOptional<z.ZodAny>;
+    funding: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>]>>;
+    os: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    cpu: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    sideEffects: z.ZodOptional<z.ZodAny>;
+    unpkg: z.ZodOptional<z.ZodAny>;
+    homepage: z.ZodOptional<z.ZodAny>;
+}, "strip", z.ZodTypeAny, {
+    exports?: Map<string, string>;
+    name?: string;
+    version?: string;
+    private?: boolean;
+    description?: string;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    bin?: Map<string, string>;
+    repository?: any;
+    keywords?: string[];
+    author?: any;
+    contributors?: (string | {})[];
+    license?: any;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    browser?: string | Record<string, string>;
+    funding?: string | {};
+    os?: string[];
+    cpu?: string[];
+    maintainers?: any;
+    bugs?: any;
+    sideEffects?: any;
+    unpkg?: any;
+    homepage?: any;
+}, {
+    exports?: string | Record<string, string>;
+    name?: string;
+    version?: string;
+    private?: boolean;
+    description?: string;
+    dependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    bin?: string | Record<string, string>;
+    repository?: any;
+    keywords?: string[];
+    author?: any;
+    contributors?: (string | {})[];
+    license?: any;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    browser?: string | Record<string, string>;
+    funding?: string | {};
+    os?: string[];
+    cpu?: string[];
+    maintainers?: any;
+    bugs?: any;
+    sideEffects?: any;
+    unpkg?: any;
+    homepage?: any;
+}>;
+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/resolveDirs.d.cts

@@ -0,0 +1,12 @@
+export type Args = {
+    sourceDir?: string;
+    packagePath?: string;
+    outputDir?: string;
+};
+export declare function resolveDirs(args: Args): {
+    sourceDir: string;
+    packagePath: string;
+    outDir: string;
+    outBinsDir: string;
+};
+export type Dirs = ReturnType<typeof resolveDirs>;

package/src/run.d.cts

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

package/src/tasks/binsTask.d.cts

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

package/src/tasks/buildTypesTask/buildTypesTask.d.cts

@@ -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 {};