@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/build/providers/mkdist/mkdist-impl/utils/vue-dts.js

@@ -0,0 +1,175 @@
+import { createRequire } from "node:module";
+import { normalize } from "@reliverse/pathkit";
+import { satisfies } from "semver";
+import { augmentWithDiagnostics, extractDeclarations } from "./dts.js";
+const require = createRequire(import.meta.url);
+export async function getVueDeclarations(vfs, opts) {
+  const fileMapping = getFileMapping(vfs);
+  const srcFiles = Object.keys(fileMapping);
+  const originFiles = Object.values(fileMapping);
+  if (originFiles.length === 0) {
+    return;
+  }
+  const { readPackageJSON } = await import("pkg-types");
+  const pkgInfo = await readPackageJSON("vue-tsc").catch(() => {
+  });
+  if (!pkgInfo) {
+    console.warn("[mkdist] Please install `vue-tsc` to generate Vue SFC declarations.");
+    return;
+  }
+  const { version } = pkgInfo;
+  let output;
+  switch (true) {
+    // @ts-expect-error TODO: fix ts
+    case satisfies(version, "^1.8.27"): {
+      output = await emitVueTscV1(vfs, srcFiles, originFiles, opts);
+      break;
+    }
+    // @ts-expect-error TODO: fix ts
+    case satisfies(version, "~v2.0.0"): {
+      output = await emitVueTscV2(vfs, srcFiles, originFiles, opts);
+      break;
+    }
+    default: {
+      output = await emitVueTscLatest(vfs, srcFiles, originFiles, opts);
+    }
+  }
+  return output;
+}
+const SFC_EXT_RE = /\.vue\.[cm]?[jt]s$/;
+function getFileMapping(vfs) {
+  const files = /* @__PURE__ */ Object.create(null);
+  for (const [srcPath] of vfs) {
+    if (SFC_EXT_RE.test(srcPath)) {
+      files[srcPath.replace(SFC_EXT_RE, ".vue")] = srcPath;
+    }
+  }
+  return files;
+}
+async function emitVueTscV1(vfs, inputFiles, originFiles, opts) {
+  const vueTsc = await import("vue-tsc").then((r) => r.default || r).catch(() => {
+  });
+  const ts = require("typescript");
+  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
+  const _tsSysWriteFile = ts.sys.writeFile;
+  ts.sys.writeFile = (filename, content) => {
+    vfs.set(filename, content);
+  };
+  const _tsSysReadFile = ts.sys.readFile;
+  ts.sys.readFile = (filename, encoding) => {
+    if (vfs.has(filename)) {
+      return vfs.get(filename);
+    }
+    return _tsSysReadFile(filename, encoding);
+  };
+  try {
+    const program = vueTsc.createProgram({
+      rootNames: inputFiles,
+      // @ts-expect-error TODO: fix ts
+      options: opts.typescript.compilerOptions,
+      host: tsHost
+    });
+    const result = program.emit();
+    const output = extractDeclarations(vfs, originFiles, opts);
+    augmentWithDiagnostics(result, output, tsHost, ts);
+    return output;
+  } finally {
+    ts.sys.writeFile = _tsSysWriteFile;
+    ts.sys.readFile = _tsSysReadFile;
+  }
+}
+async function emitVueTscV2(vfs, inputFiles, originFiles, opts) {
+  const { resolve: resolveModule } = await import("mlly");
+  const ts = await import("typescript").then((r) => r.default || r);
+  const vueTsc = await import("vue-tsc");
+  const requireFromVueTsc = createRequire(await resolveModule("vue-tsc"));
+  const vueLanguageCore = requireFromVueTsc("@vue/language-core");
+  const volarTs = requireFromVueTsc("@volar/typescript");
+  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
+  tsHost.writeFile = (filename, content) => {
+    vfs.set(filename, vueTsc.removeEmitGlobalTypes(content));
+  };
+  const _tsReadFile = tsHost.readFile.bind(tsHost);
+  tsHost.readFile = (filename) => {
+    if (vfs.has(filename)) {
+      return vfs.get(filename);
+    }
+    return _tsReadFile(filename);
+  };
+  const _tsFileExist = tsHost.fileExists.bind(tsHost);
+  tsHost.fileExists = (filename) => {
+    return vfs.has(filename) || _tsFileExist(filename);
+  };
+  const programOptions = {
+    rootNames: inputFiles,
+    // @ts-expect-error TODO: fix ts
+    options: opts.typescript.compilerOptions,
+    host: tsHost
+  };
+  const createProgram = volarTs.proxyCreateProgram(ts, ts.createProgram, (ts2, options) => {
+    const vueLanguagePlugin = vueLanguageCore.createVueLanguagePlugin(
+      ts2,
+      (id) => id,
+      () => "",
+      (fileName) => {
+        const fileMap = /* @__PURE__ */ new Set();
+        for (const vueFileName of options.rootNames.map((rootName) => normalize(rootName))) {
+          fileMap.add(vueFileName);
+        }
+        return fileMap.has(fileName);
+      },
+      options.options,
+      // @ts-expect-error TODO: fix ts
+      {}
+    );
+    return [vueLanguagePlugin];
+  });
+  const program = createProgram(programOptions);
+  const result = program.emit();
+  const output = extractDeclarations(vfs, originFiles, opts);
+  augmentWithDiagnostics(result, output, tsHost, ts);
+  return output;
+}
+async function emitVueTscLatest(vfs, inputFiles, originFiles, opts) {
+  const { resolve: resolveModule } = await import("mlly");
+  const ts = await import("typescript").then((r) => r.default || r);
+  const requireFromVueTsc = createRequire(await resolveModule("vue-tsc"));
+  const vueLanguageCore = requireFromVueTsc("@vue/language-core");
+  const volarTs = requireFromVueTsc("@volar/typescript");
+  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
+  tsHost.writeFile = (filename, content) => {
+    vfs.set(filename, content);
+  };
+  const _tsReadFile = tsHost.readFile.bind(tsHost);
+  tsHost.readFile = (filename) => {
+    if (vfs.has(filename)) {
+      return vfs.get(filename);
+    }
+    return _tsReadFile(filename);
+  };
+  const _tsFileExist = tsHost.fileExists.bind(tsHost);
+  tsHost.fileExists = (filename) => {
+    return vfs.has(filename) || _tsFileExist(filename);
+  };
+  const programOptions = {
+    rootNames: inputFiles,
+    // @ts-expect-error TODO: fix ts
+    options: opts.typescript.compilerOptions,
+    host: tsHost
+  };
+  const createProgram = volarTs.proxyCreateProgram(ts, ts.createProgram, (ts2, options) => {
+    const vueLanguagePlugin = vueLanguageCore.createVueLanguagePlugin(
+      ts2,
+      options.options,
+      // @ts-expect-error TODO: fix ts
+      vueLanguageCore.createParsedCommandLineByJson(ts2, ts2.sys, opts.rootDir, {}, void 0, true).vueOptions,
+      (id) => id
+    );
+    return [vueLanguagePlugin];
+  });
+  const program = createProgram(programOptions);
+  const result = program.emit();
+  const output = extractDeclarations(vfs, originFiles, opts);
+  augmentWithDiagnostics(result, output, tsHost, ts);
+  return output;
+}

package/bin/app/build/providers/mkdist/mkdist-mod.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../../../types/mod.js";
+export declare function mkdistBuild(ctx: BuildContext): Promise<void>;

package/bin/app/build/providers/mkdist/mkdist-mod.js

@@ -0,0 +1,92 @@
+import { dirname as pathDirname, relative } from "@reliverse/pathkit";
+import { relinka } from "@reliverse/relinka";
+import { rmdir, symlink, warn } from "../utils.js";
+import { mkdist } from "./mkdist-impl/make.js";
+export async function mkdistBuild(ctx) {
+  const entries = ctx.options.entries.filter((e) => e.builder === "mkdist");
+  if (entries.length === 0) {
+    return;
+  }
+  await ctx.hooks.callHook("mkdist:entries", ctx, entries);
+  let processedEntries = 0;
+  let totalWrittenFiles = 0;
+  let totalErrors = 0;
+  relinka("verbose", `Processing ${entries.length} mkdist entries...`);
+  for (const entry of entries) {
+    processedEntries++;
+    relinka("verbose", `Processing entry ${processedEntries}/${entries.length}: ${entry.input}`);
+    const distDir = entry.outDir || entry.input;
+    if (ctx.options.transpileStub) {
+      await rmdir(distDir);
+      await symlink(entry.input, distDir);
+      continue;
+    }
+    let srcDir;
+    if (typeof entry.input === "string" && !entry.input.endsWith("/")) {
+      srcDir = ctx.options.isLib ? pathDirname(entry.input) : entry.input;
+      relinka(
+        "verbose",
+        `[mkdist] Using directory from file path: ${srcDir} (from: ${entry.input})`
+      );
+    } else {
+      srcDir = entry.input;
+      relinka("verbose", `[mkdist] Using directory directly: ${srcDir}`);
+    }
+    const mkdistOptions = {
+      cleanDist: false,
+      distDir,
+      rootDir: ctx.options.rootDir,
+      srcDir,
+      format: "esm",
+      ext: entry.ext || "js",
+      ...entry
+    };
+    relinka(
+      "verbose",
+      `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
+    );
+    await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
+    try {
+      const { result: output, duration } = await mkdist(mkdistOptions);
+      relinka("verbose", `[mkdist] Entry ${processedEntries} completed in ${duration}ms`);
+      totalWrittenFiles += output.writtenFiles.length;
+      ctx.buildEntries.push({
+        chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
+        path: distDir,
+        isLib: ctx.options.isLib
+      });
+      await ctx.hooks.callHook("mkdist:entry:build", ctx, entry, output);
+      if (output.errors && output.errors.length > 0) {
+        totalErrors += output.errors.length;
+        for (const error of output.errors) {
+          warn(
+            ctx,
+            `mkdist build failed for \`${relative(ctx.options.rootDir, error.filename)}\`:
+${error.errors.map((e) => `  - ${e}`).join("\n")}`
+          );
+        }
+      }
+    } catch (error) {
+      totalErrors++;
+      warn(
+        ctx,
+        `mkdist build failed for entry ${entry.input}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  await ctx.hooks.callHook("mkdist:done", ctx);
+  if (entries.length > 0 && ctx.options.transpileWatch) {
+    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
+  }
+  if (totalErrors > 0) {
+    relinka(
+      "warn",
+      `Processed ${entries.length} entries with ${totalErrors} errors. ${totalWrittenFiles} files written.`
+    );
+  } else {
+    relinka(
+      "success",
+      `Successfully processed ${entries.length} entries. ${totalWrittenFiles} files written.`
+    );
+  }
+}

package/bin/app/build/providers/rollup/build.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../../../types/mod.js";
+export declare function rollupBuild(ctx: BuildContext): Promise<void>;

package/bin/app/build/providers/rollup/config.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext, RollupOptions } from "../../../types/mod.js";
+export declare function getRollupOptions(ctx: BuildContext): RollupOptions;

package/bin/app/build/providers/rollup/config.js

@@ -0,0 +1,112 @@
+import { isAbsolute, resolve, resolveAlias } from "@reliverse/pathkit";
+import { parseNodeModulePath } from "mlly";
+import { arrayIncludes, getpkg, warn } from "../utils.js";
+import { cjsPlugin } from "./plugins/cjs.js";
+import { esbuild } from "./plugins/esbuild.js";
+import { JSONPlugin } from "./plugins/json.js";
+import { rawPlugin } from "./plugins/raw.js";
+import { shebangPlugin } from "./plugins/shebang.js";
+import { DEFAULT_EXTENSIONS, getChunkFilename, resolveAliases } from "./utils.js";
+const replaceModule = await import("@rollup/plugin-replace");
+const replace = replaceModule.default || replaceModule;
+const aliasModule = await import("@rollup/plugin-alias");
+const alias = aliasModule.default || aliasModule;
+const commonjsModule = await import("@rollup/plugin-commonjs");
+const commonjs = commonjsModule.default || commonjsModule;
+const nodeResolveModule = await import("@rollup/plugin-node-resolve");
+const nodeResolve = nodeResolveModule.nodeResolve || nodeResolveModule.default || nodeResolveModule;
+export function getRollupOptions(ctx) {
+  const _aliases = resolveAliases(ctx);
+  return {
+    external(originalId) {
+      const resolvedId = resolveAlias(originalId, _aliases);
+      const pkgName = parseNodeModulePath(resolvedId)?.name || parseNodeModulePath(originalId)?.name || getpkg(originalId);
+      if (arrayIncludes(ctx.options.externals, pkgName) || arrayIncludes(ctx.options.externals, originalId) || arrayIncludes(ctx.options.externals, resolvedId)) {
+        return true;
+      }
+      for (const id of [originalId, resolvedId]) {
+        if (id.startsWith(".") || isAbsolute(id) || /src[/\\]/.test(id) || ctx.pkg.name && id.startsWith(ctx.pkg.name)) {
+          return false;
+        }
+      }
+      if (ctx.options.rollup.inlineDependencies === true || Array.isArray(ctx.options.rollup.inlineDependencies) && (arrayIncludes(ctx.options.rollup.inlineDependencies, pkgName) || arrayIncludes(ctx.options.rollup.inlineDependencies, originalId) || arrayIncludes(ctx.options.rollup.inlineDependencies, resolvedId))) {
+        return false;
+      }
+      warn(ctx, `Implicitly bundling "${originalId}"`);
+      return false;
+    },
+    input: Object.fromEntries(
+      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [entry.name, resolve(ctx.options.rootDir, entry.input)])
+    ),
+    onwarn(warning, rollupWarn) {
+      if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+        rollupWarn(warning);
+      }
+    },
+    output: [
+      ctx.options.rollup.emitCJS && {
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "cjs"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].cjs",
+        exports: "auto",
+        externalLiveBindings: false,
+        format: "cjs",
+        freeze: false,
+        generatedCode: { constBindings: true },
+        interop: "compat",
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.output
+      },
+      {
+        chunkFileNames: (chunk) => getChunkFilename(ctx, chunk, "mjs"),
+        dir: resolve(ctx.options.rootDir, ctx.options.outDir),
+        entryFileNames: "[name].mjs",
+        exports: "auto",
+        externalLiveBindings: false,
+        format: "esm",
+        freeze: false,
+        generatedCode: { constBindings: true },
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.output
+      }
+    ].filter(Boolean),
+    plugins: [
+      ctx.options.rollup.replace && replace({
+        ...ctx.options.rollup.replace,
+        values: {
+          ...ctx.options.replace,
+          ...ctx.options.rollup.replace.values
+        }
+      }),
+      ctx.options.rollup.alias && alias({
+        ...ctx.options.rollup.alias,
+        entries: _aliases
+      }),
+      ctx.options.rollup.resolve && nodeResolve({
+        exportConditions: ["production"],
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.resolve
+      }),
+      ctx.options.rollup.json && JSONPlugin({
+        ...ctx.options.rollup.json
+      }),
+      shebangPlugin(),
+      ctx.options.rollup.esbuild && esbuild({
+        sourcemap: ctx.options.transpileSourcemap,
+        ...ctx.options.rollup.esbuild
+      }),
+      ctx.options.rollup.commonjs && commonjs({
+        extensions: DEFAULT_EXTENSIONS,
+        ...ctx.options.rollup.commonjs
+      }),
+      ctx.options.rollup.preserveDynamicImports && {
+        name: "dler=preserve-dynamic-imports",
+        renderDynamicImport() {
+          return { left: "import(", right: ")" };
+        }
+      },
+      ctx.options.rollup.cjsBridge && cjsPlugin(),
+      rawPlugin()
+    ].filter((p) => !!p)
+  };
+}

package/bin/app/build/providers/rollup/plugins/cjs.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "rollup";
+import type { BuildContext } from "../../../../types/mod.js";
+export declare function cjsPlugin(): Plugin;
+export declare function fixCJSExportTypePlugin(ctx: BuildContext): Plugin;

package/bin/app/build/providers/rollup/plugins/esbuild.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "rollup";
+import type { EsbuildOptions } from "../../../../types/mod.js";
+export declare function esbuild(options: EsbuildOptions): Plugin;

package/bin/app/build/providers/rollup/plugins/shebang.js

@@ -0,0 +1,42 @@
+import { promises as fsp } from "node:fs";
+import { resolve } from "@reliverse/pathkit";
+const SHEBANG_RE = /^#![^\n]*/;
+export function getShebang(code, append = "\n") {
+  const m = SHEBANG_RE.exec(code);
+  return m ? m[0] + append : "";
+}
+export async function makeExecutable(filePath) {
+  await fsp.chmod(
+    filePath,
+    493
+    /* rwx r-x r-x */
+  ).catch(() => {
+  });
+}
+export function removeShebangPlugin() {
+  return {
+    name: "dler-remove-shebang",
+    renderChunk(code) {
+      return code.replace(SHEBANG_RE, "");
+    }
+  };
+}
+export function shebangPlugin() {
+  return {
+    name: "dler-shebang",
+    async writeBundle(options, bundle) {
+      for (const [fileName, output] of Object.entries(bundle)) {
+        if (output.type !== "chunk") {
+          continue;
+        }
+        if (SHEBANG_RE.exec(output.code)) {
+          if (!options.dir) {
+            throw new Error("options.dir is required for shebang plugin");
+          }
+          const outFile = resolve(options.dir, fileName);
+          await makeExecutable(outFile);
+        }
+      }
+    }
+  };
+}

package/bin/app/build/providers/rollup/stub.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../../../types/mod.js";
+export declare function rollupStub(ctx: BuildContext): Promise<void>;

package/bin/app/build/providers/rollup/stub.js

@@ -0,0 +1,125 @@
+import { promises as fsp } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, relative, resolve } from "@reliverse/pathkit";
+import { fileURLToPath, resolveModuleExportNames, resolvePath } from "mlly";
+import { warn } from "../utils.js";
+import { getShebang, makeExecutable } from "./plugins/shebang.js";
+import { DEFAULT_EXTENSIONS, resolveAliases } from "./utils.js";
+export async function rollupStub(ctx) {
+  const babelPlugins = ctx.options.transpileStubOptions.jiti.transformOptions?.babel?.plugins;
+  const importedBabelPlugins = [];
+  const serializedJitiOptions = JSON.stringify(
+    {
+      ...ctx.options.transpileStubOptions.jiti,
+      alias: {
+        ...resolveAliases(ctx),
+        ...ctx.options.transpileStubOptions.jiti.alias
+      },
+      transformOptions: {
+        ...ctx.options.transpileStubOptions.jiti.transformOptions,
+        babel: {
+          ...ctx.options.transpileStubOptions.jiti.transformOptions?.babel,
+          plugins: "__$BABEL_PLUGINS"
+        }
+      }
+    },
+    null,
+    2
+  ).replace(
+    '"__$BABEL_PLUGINS"',
+    Array.isArray(babelPlugins) ? `[${babelPlugins.map((plugin, i) => {
+      if (Array.isArray(plugin)) {
+        const [name, ...args] = plugin;
+        importedBabelPlugins.push(name);
+        return `[${[`plugin${i}`, ...args.map((val) => JSON.stringify(val))].join(", ")}]`;
+      }
+      importedBabelPlugins.push(plugin);
+      return `plugin${i}`;
+    }).join(",")}]` : "[]"
+  );
+  for (const entry of ctx.options.entries.filter((entry2) => entry2.builder === "rollup")) {
+    const output = resolve(
+      ctx.options.rootDir,
+      ctx.options.outDir,
+      entry.name || basename(entry.input, extname(entry.input))
+    );
+    const isESM = ctx.pkg.type === "module";
+    const resolvedEntry = fileURLToPath(ctx.jiti.esmResolve(entry.input));
+    const resolvedEntryWithoutExt = resolvedEntry.slice(
+      0,
+      Math.max(0, resolvedEntry.length - extname(resolvedEntry).length)
+    );
+    const resolvedEntryForTypeImport = isESM ? resolvedEntry.replace(/(\.m?)(ts)$/, "$1js") : resolvedEntryWithoutExt;
+    const code = await fsp.readFile(resolvedEntry, "utf8");
+    const shebang = getShebang(code);
+    await mkdir(dirname(output), { recursive: true });
+    if (ctx.options.rollup.emitCJS) {
+      const jitiCJSPath = relative(
+        dirname(output),
+        await resolvePath("jiti", {
+          conditions: ["node", "require"],
+          url: import.meta.url
+        })
+      );
+      await writeFile(
+        `${output}.cjs`,
+        shebang + [
+          `const { createJiti } = require(${JSON.stringify(jitiCJSPath)})`,
+          ...importedBabelPlugins.map(
+            (plugin, i) => `const plugin${i} = require(${JSON.stringify(plugin)})`
+          ),
+          "",
+          `const jiti = createJiti(__filename, ${serializedJitiOptions})`,
+          "",
+          `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
+          `module.exports = jiti(${JSON.stringify(resolvedEntry)})`
+        ].join("\n")
+      );
+    }
+    const namedExports = await resolveModuleExportNames(resolvedEntry, {
+      extensions: DEFAULT_EXTENSIONS
+    }).catch((error) => {
+      warn(ctx, `Cannot analyze ${resolvedEntry} for exports:${error}`);
+      return [];
+    });
+    const hasDefaultExport = namedExports.includes("default") || namedExports.length === 0;
+    const jitiESMPath = relative(
+      dirname(output),
+      await resolvePath("jiti", {
+        conditions: ["node", "import"],
+        url: import.meta.url
+      })
+    );
+    await writeFile(
+      `${output}.mjs`,
+      shebang + [
+        `import { createJiti } from ${JSON.stringify(jitiESMPath)};`,
+        ...importedBabelPlugins.map(
+          (plugin, i) => `import plugin${i} from ${JSON.stringify(plugin)}`
+        ),
+        "",
+        `const jiti = createJiti(import.meta.url, ${serializedJitiOptions})`,
+        "",
+        `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
+        `const _module = await jiti.import(${JSON.stringify(resolvedEntry)});`,
+        hasDefaultExport ? "\nexport default _module?.default ?? _module;" : "",
+        ...namedExports.filter((name) => name !== "default").map((name) => `export const ${name} = _module.${name};`)
+      ].join("\n")
+    );
+    if (ctx.options.declaration) {
+      const dtsContent = [
+        `export * from ${JSON.stringify(resolvedEntryForTypeImport)};`,
+        hasDefaultExport ? `export { default } from ${JSON.stringify(resolvedEntryForTypeImport)};` : ""
+      ].join("\n");
+      await writeFile(`${output}.d.cts`, dtsContent);
+      await writeFile(`${output}.d.mts`, dtsContent);
+      if (ctx.options.declaration === "compatible" || ctx.options.declaration === true) {
+        await writeFile(`${output}.d.ts`, dtsContent);
+      }
+    }
+    if (shebang) {
+      await makeExecutable(`${output}.cjs`);
+      await makeExecutable(`${output}.mjs`);
+    }
+  }
+}

package/bin/app/build/providers/rollup/utils.d.ts

@@ -0,0 +1,5 @@
+import type { PreRenderedChunk } from "rollup";
+import type { BuildContext } from "../../../types/mod.js";
+export declare const DEFAULT_EXTENSIONS: string[];
+export declare function getChunkFilename(ctx: BuildContext, chunk: PreRenderedChunk, ext: string): string;
+export declare function resolveAliases(ctx: BuildContext): Record<string, string>;

package/bin/app/build/providers/rollup/watch.d.ts

@@ -0,0 +1,2 @@
+import type { RollupOptions } from "../../../types/mod.js";
+export declare function rollupWatch(rollupOptions: RollupOptions): void;

package/bin/app/build/providers/untyped/untyped-mod.d.ts

@@ -0,0 +1,2 @@
+import type { BuildContext } from "../../../types/mod.js";
+export declare function typesBuild(ctx: BuildContext): Promise<void>;