@reliverse/dler 1.7.7 → 1.7.9

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/make.js

@@ -0,0 +1,133 @@
+import defu from "defu";
+import fsp from "node:fs/promises";
+import { resolve, extname, join, basename, dirname } from "pathe";
+import { glob } from "tinyglobby";
+import { createLoader } from "./loader.js";
+import { getDeclarations, normalizeCompilerOptions } from "./utils/dts.js";
+import { copyFileWithStream } from "./utils/fs.js";
+import { getVueDeclarations } from "./utils/vue-dts.js";
+export async function mkdist(options = {}) {
+  options.rootDir = resolve(process.cwd(), options.rootDir || ".");
+  options.srcDir = resolve(options.rootDir, options.srcDir || "src");
+  options.distDir = resolve(options.rootDir, options.distDir || "dist");
+  if (options.cleanDist !== false) {
+    await fsp.unlink(options.distDir).catch(() => {
+    });
+    await fsp.rm(options.distDir, { recursive: true, force: true });
+    await fsp.mkdir(options.distDir, { recursive: true });
+  }
+  const filePaths = await glob(options.pattern || "**", {
+    absolute: false,
+    ignore: ["**/node_modules", "**/coverage", "**/.git"],
+    cwd: options.srcDir,
+    dot: true,
+    ...options.globOptions
+  });
+  const files = filePaths.map((path) => {
+    const sourcePath = resolve(options.srcDir, path);
+    return {
+      path,
+      srcPath: sourcePath,
+      extension: extname(path),
+      getContents: () => fsp.readFile(sourcePath, { encoding: "utf8" })
+    };
+  });
+  options.typescript ||= {};
+  if (options.typescript.compilerOptions) {
+    options.typescript.compilerOptions = await normalizeCompilerOptions(
+      options.typescript.compilerOptions
+    );
+  }
+  options.typescript.compilerOptions = defu(
+    { noEmit: false },
+    options.typescript.compilerOptions,
+    {
+      allowJs: true,
+      declaration: true,
+      skipLibCheck: true,
+      strictNullChecks: true,
+      emitDeclarationOnly: true,
+      allowImportingTsExtensions: true,
+      allowNonTsExtensions: true
+    }
+  );
+  const { loadFile } = createLoader(options);
+  const outputs = [];
+  for (const file of files) {
+    outputs.push(...await loadFile(file) || []);
+  }
+  for (const output of outputs.filter((o) => o.extension)) {
+    const renamed = basename(output.path, extname(output.path)) + output.extension;
+    output.path = join(dirname(output.path), renamed);
+    if (outputs.some((o) => o !== output && o.path === output.path)) {
+      output.skip = true;
+    }
+  }
+  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
+  if (dtsOutputs.length > 0) {
+    const vfs = new Map(dtsOutputs.map((o) => [o.srcPath, o.contents || ""]));
+    const declarations = /* @__PURE__ */ Object.create(null);
+    for (const loader of [getVueDeclarations, getDeclarations]) {
+      Object.assign(declarations, await loader(vfs, options));
+    }
+    for (const output of dtsOutputs) {
+      const result = declarations[output.srcPath];
+      output.contents = result?.contents || "";
+      if (result.errors) {
+        output.errors = result.errors;
+      }
+    }
+  }
+  const outPaths = new Set(outputs.map((o) => o.path));
+  const resolveId = (from, id = "", resolveExtensions) => {
+    if (!id.startsWith(".")) {
+      return id;
+    }
+    for (const extension of resolveExtensions) {
+      if (outPaths.has(join(dirname(from), id + extension))) {
+        return id + extension;
+      }
+    }
+    return id;
+  };
+  const esmResolveExtensions = ["", "/index.mjs", "/index.js", ".mjs", ".ts", ".js"];
+  for (const output of outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js")) {
+    output.contents = output.contents.replace(
+      /(import|export)(\s+(?:.+|{[\s\w,]+})\s+from\s+["'])(.*)(["'])/g,
+      (_, type, head, id, tail) => type + head + resolveId(output.path, id, esmResolveExtensions) + tail
+    ).replace(
+      /import\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "import(" + head + resolveId(output.path, id, esmResolveExtensions) + tail + ")"
+    );
+  }
+  const cjsResolveExtensions = ["", "/index.cjs", ".cjs"];
+  for (const output of outputs.filter((o) => o.extension === ".cjs")) {
+    output.contents = output.contents.replace(
+      /require\((["'])(.*)(["'])\)/g,
+      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
+    );
+  }
+  const writtenFiles = [];
+  const errors = [];
+  await Promise.all(
+    outputs.filter((o) => !o.skip).map(async (output) => {
+      const outFile = join(options.distDir, output.path);
+      await fsp.mkdir(dirname(outFile), { recursive: true });
+      await (output.raw ? (
+        // @ts-expect-error TODO: fix ts
+        copyFileWithStream(output.srcPath, outFile)
+      ) : (
+        // @ts-expect-error TODO: fix ts
+        fsp.writeFile(outFile, output.contents, "utf8")
+      ));
+      writtenFiles.push(outFile);
+      if (output.errors) {
+        errors.push({ filename: outFile, errors: output.errors });
+      }
+    })
+  );
+  return {
+    errors,
+    writtenFiles
+  };
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/dts.d.ts

@@ -0,0 +1,11 @@
+import type { TSConfig } from "pkg-types";
+import type { CompilerHost, EmitResult } from "typescript";
+import type { MkdistOptions } from "../../../../../../../sdk-types.js";
+export declare function normalizeCompilerOptions(_options: TSConfig["compilerOptions"]): Promise<any>;
+export type DeclarationOutput = Record<string, {
+    contents: string;
+    errors?: Error[];
+}>;
+export declare function getDeclarations(vfs: Map<string, string>, opts?: MkdistOptions): Promise<DeclarationOutput>;
+export declare function extractDeclarations(vfs: Map<string, string>, inputFiles: string[], opts?: MkdistOptions): DeclarationOutput;
+export declare function augmentWithDiagnostics(result: EmitResult, output: DeclarationOutput, tsHost: CompilerHost, ts: typeof import("typescript")): void;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/dts.js

@@ -0,0 +1,94 @@
+import { findStaticImports, findDynamicImports, findExports, findTypeExports } from "mlly";
+import { statSync } from "node:fs";
+import { resolve } from "pathe";
+export async function normalizeCompilerOptions(_options) {
+  const ts = await import("typescript").then((r) => r.default || r);
+  return ts.convertCompilerOptionsFromJson(_options, process.cwd()).options;
+}
+export async function getDeclarations(vfs, opts) {
+  const ts = await import("typescript").then((r) => r.default || r);
+  const inputFiles = [...vfs.keys()];
+  const tsHost = ts.createCompilerHost(opts.typescript.compilerOptions);
+  tsHost.writeFile = (fileName, declaration) => {
+    vfs.set(fileName, declaration);
+  };
+  const _readFile = tsHost.readFile;
+  tsHost.readFile = (filename) => {
+    if (vfs.has(filename)) {
+      return vfs.get(filename);
+    }
+    return _readFile(filename);
+  };
+  const program = ts.createProgram(inputFiles, opts.typescript.compilerOptions, tsHost);
+  const result = program.emit();
+  const output = extractDeclarations(vfs, inputFiles, opts);
+  augmentWithDiagnostics(result, output, tsHost, ts);
+  return output;
+}
+const JS_EXT_RE = /\.(m|c)?(ts|js)$/;
+const JSX_EXT_RE = /\.(m|c)?(ts|js)x?$/;
+const RELATIVE_RE = /^\.{1,2}[/\\]/;
+export function extractDeclarations(vfs, inputFiles, opts) {
+  const output = {};
+  for (const filename of inputFiles) {
+    const dtsFilename = filename.replace(JSX_EXT_RE, ".d.$1ts");
+    let contents = vfs.get(dtsFilename) || "";
+    if (opts?.addRelativeDeclarationExtensions) {
+      const ext = filename.match(JS_EXT_RE)?.[0].replace(/ts$/, "js") || ".js";
+      const imports = findStaticImports(contents);
+      const exports = findExports(contents);
+      const typeExports = findTypeExports(contents);
+      const dynamicImports = findDynamicImports(contents).map((dynamicImport) => {
+        let specifier;
+        try {
+          const value = JSON.parse(dynamicImport.expression);
+          if (typeof value === "string") {
+            specifier = value;
+          }
+        } catch {
+        }
+        return {
+          code: dynamicImport.code,
+          specifier
+        };
+      });
+      for (const spec of [...exports, ...typeExports, ...imports, ...dynamicImports]) {
+        if (!spec.specifier || !RELATIVE_RE.test(spec.specifier)) {
+          continue;
+        }
+        const srcPath = resolve(filename, "..", spec.specifier);
+        const srcDtsPath = srcPath + ext.replace(JS_EXT_RE, ".d.$1ts");
+        let specifier = spec.specifier;
+        try {
+          if (!vfs.get(srcDtsPath)) {
+            const stat = statSync(srcPath);
+            if (stat.isDirectory()) {
+              specifier += "/index";
+            }
+          }
+        } catch {
+        }
+        contents = contents.replace(spec.code, spec.code.replace(spec.specifier, specifier + ext));
+      }
+    }
+    output[filename] = { contents };
+    vfs.delete(filename);
+  }
+  return output;
+}
+export function augmentWithDiagnostics(result, output, tsHost, ts) {
+  if (result.diagnostics?.length) {
+    for (const diagnostic of result.diagnostics) {
+      const filename = diagnostic.file?.fileName;
+      if (filename in output) {
+        output[filename].errors = output[filename].errors || [];
+        output[filename].errors.push(
+          new TypeError(ts.formatDiagnostics([diagnostic], tsHost), {
+            cause: diagnostic
+          })
+        );
+      }
+    }
+    console.error(ts.formatDiagnostics(result.diagnostics, tsHost));
+  }
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/fs.d.ts

@@ -0,0 +1 @@
+export declare function copyFileWithStream(sourcePath: string, outPath: string): Promise<unknown>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/fs.js

@@ -0,0 +1,15 @@
+import { createReadStream, createWriteStream } from "node:fs";
+import { pipeline } from "node:stream";
+export function copyFileWithStream(sourcePath, outPath) {
+  const sourceStream = createReadStream(sourcePath);
+  const outStream = createWriteStream(outPath);
+  return new Promise((resolve, reject) => {
+    pipeline(sourceStream, outStream, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+}

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/vue-dts.d.ts

@@ -0,0 +1,3 @@
+import type { MkdistOptions } from "../../../../../../../sdk-types.js";
+import type { DeclarationOutput } from "./dts";
+export declare function getVueDeclarations(vfs: Map<string, string>, opts?: MkdistOptions): Promise<DeclarationOutput>;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/mkdist-impl/utils/vue-dts.js

@@ -0,0 +1,175 @@
+import { createRequire } from "node:module";
+import { normalize } from "pathe";
+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(() => void 0);
+  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,
+      // @ts-expect-error TODO: fix ts
+      (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);
+      },
+      // @ts-expect-error TODO: fix ts
+      options.options,
+      vueLanguageCore.resolveVueCompilerOptions({})
+    );
+    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/libs/sdk/sdk-impl/build/bundlers/unified/mkdist/{mkdist.js → mkdist-mod.js}

@@ -1,15 +1,9 @@
 import { relative, dirname as pathDirname } from "@reliverse/pathkit";
 import { relinka } from "@reliverse/relinka";
-import { mkdist } from "mkdist";
-import {
-  rmdir,
-  symlink,
-  warn
-} from "../utils.js";
+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"
-  );
+  const entries = ctx.options.entries.filter((e) => e.builder === "mkdist");
   await ctx.hooks.callHook("mkdist:entries", ctx, entries);
   for (const entry of entries) {
     const distDir = entry.outDir || entry.input;
@@ -41,12 +35,7 @@ export async function mkdistBuild(ctx) {
         "verbose",
         `[mkdist] Building with options: srcDir=${mkdistOptions.srcDir}, distDir=${mkdistOptions.distDir}, rootDir=${mkdistOptions.rootDir}`
       );
-      await ctx.hooks.callHook(
-        "mkdist:entry:options",
-        ctx,
-        entry,
-        mkdistOptions
-      );
+      await ctx.hooks.callHook("mkdist:entry:options", ctx, entry, mkdistOptions);
       const output = await mkdist(mkdistOptions);
       ctx.buildEntries.push({
         chunks: output.writtenFiles.map((p) => relative(ctx.options.outDir, p)),
@@ -67,9 +56,6 @@ ${error.errors.map((e) => `  - ${e}`).join("\n")}`
   }
   await ctx.hooks.callHook("mkdist:done", ctx);
   if (entries.length > 0 && ctx.options.transpileWatch) {
-    relinka(
-      "warn",
-      "`mkdist` builder does not support transpileWatch mode yet."
-    );
+    relinka("warn", "`mkdist` builder does not support transpileWatch mode yet.");
   }
 }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/build.js

@@ -35,9 +35,7 @@ export async function rollupBuild(ctx) {
       if (entry.isEntry) {
         ctx.buildEntries.push({
           bytes: Buffer.byteLength(entry.code, "utf8"),
-          chunks: entry.imports.filter(
-            (i) => outputChunks.find((c) => c.fileName === i)
-          ),
+          chunks: entry.imports.filter((i) => outputChunks.find((c) => c.fileName === i)),
           exports: entry.exports,
           modules: Object.entries(entry.modules).map(([id, mod]) => ({
             bytes: mod.renderedLength,
@@ -55,10 +53,7 @@ export async function rollupBuild(ctx) {
   if (ctx.options.transpileWatch) {
     rollupWatch(rollupOptions);
     if (ctx.options.declaration && ctx.options.transpileWatch) {
-      relinka(
-        "warn",
-        "`rollup` DTS builder does not support transpileWatch mode yet."
-      );
+      relinka("warn", "`rollup` DTS builder does not support transpileWatch mode yet.");
     }
     return;
   }

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/config.js

@@ -1,11 +1,7 @@
 import { isAbsolute, resolve } from "@reliverse/pathkit";
 import { resolveAlias } from "@reliverse/pathkit";
 import { parseNodeModulePath } from "mlly";
-import {
-  arrayIncludes,
-  getpkg,
-  warn
-} from "../utils.js";
+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";
@@ -41,10 +37,7 @@ export function getRollupOptions(ctx) {
       return false;
     },
     input: Object.fromEntries(
-      ctx.options.entries.filter((entry) => entry.builder === "rollup").map((entry) => [
-        entry.name,
-        resolve(ctx.options.rootDir, entry.input)
-      ])
+      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)) {

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/stub.js

@@ -1,10 +1,4 @@
-import {
-  basename,
-  dirname,
-  extname,
-  relative,
-  resolve
-} from "@reliverse/pathkit";
+import { basename, dirname, extname, relative, resolve } from "@reliverse/pathkit";
 import { fileURLToPath, resolveModuleExportNames, resolvePath } from "mlly";
 import { promises as fsp } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
@@ -37,18 +31,13 @@ export async function rollupStub(ctx) {
       if (Array.isArray(plugin)) {
         const [name, ...args] = plugin;
         importedBabelPlugins.push(name);
-        return `[${[
-          `plugin${i}`,
-          ...args.map((val) => JSON.stringify(val))
-        ].join(", ")}]`;
+        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"
-  )) {
+  for (const entry of ctx.options.entries.filter((entry2) => entry2.builder === "rollup")) {
     const output = resolve(
       ctx.options.rootDir,
       ctx.options.outDir,
@@ -82,19 +71,14 @@ export async function rollupStub(ctx) {
           "",
           `const jiti = createJiti(__filename, ${serializedJitiOptions})`,
           "",
-          `/** @type {import(${JSON.stringify(
-            resolvedEntryForTypeImport
-          )})} */`,
+          `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
           `module.exports = jiti(${JSON.stringify(resolvedEntry)})`
         ].join("\n")
       );
     }
-    const namedExports = await resolveModuleExportNames(
-      resolvedEntry,
-      {
-        extensions: DEFAULT_EXTENSIONS
-      }
-    ).catch((error) => {
+    const namedExports = await resolveModuleExportNames(resolvedEntry, {
+      extensions: DEFAULT_EXTENSIONS
+    }).catch((error) => {
       warn(ctx, `Cannot analyze ${resolvedEntry} for exports:${error}`);
       return [];
     });
@@ -117,9 +101,7 @@ export async function rollupStub(ctx) {
         `const jiti = createJiti(import.meta.url, ${serializedJitiOptions})`,
         "",
         `/** @type {import(${JSON.stringify(resolvedEntryForTypeImport)})} */`,
-        `const _module = await jiti.import(${JSON.stringify(
-          resolvedEntry
-        )});`,
+        `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")

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/utils.js

@@ -31,10 +31,7 @@ export function resolveAliases(ctx) {
         )
       );
     } else {
-      Object.assign(
-        aliases,
-        ctx.options.rollup.alias.entries || ctx.options.rollup.alias
-      );
+      Object.assign(aliases, ctx.options.rollup.alias.entries || ctx.options.rollup.alias);
     }
   }
   return aliases;

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/rollup/watch.js

@@ -15,10 +15,7 @@ export function rollupWatch(rollupOptions) {
     "log",
     `[dler] [rollup] Starting watchers for entries: ${inputs.map((input) => `./${relative(process.cwd(), input)}`).join(", ")}`
   );
-  relinka(
-    "warn",
-    "[dler] [rollup] Watch mode is experimental and may be unstable"
-  );
+  relinka("warn", "[dler] [rollup] Watch mode is experimental and may be unstable");
   transpileWatcher.on("change", (id, { event }) => {
     relinka("log", `${relative(".", id)} was ${event}d`);
   });

package/bin/libs/sdk/sdk-impl/build/bundlers/unified/untyped/{index.js → untyped-mod.js}

@@ -3,11 +3,7 @@ import { relinka } from "@reliverse/relinka";
 import { createJiti } from "jiti";
 import { mkdir, writeFile } from "node:fs/promises";
 import { pascalCase } from "scule";
-import {
-  generateMarkdown,
-  generateTypes,
-  resolveSchema
-} from "untyped";
+import { generateMarkdown, generateTypes, resolveSchema } from "untyped";
 import untypedPlugin from "untyped/babel-plugin";
 export async function typesBuild(ctx) {
   const entries = ctx.options.entries.filter(
@@ -33,12 +29,7 @@ export async function typesBuild(ctx) {
           }
         }
       };
-      await ctx.hooks.callHook(
-        "untyped:entry:options",
-        ctx,
-        entry,
-        jitiOptions
-      );
+      await ctx.hooks.callHook("untyped:entry:options", ctx, entry, jitiOptions);
       const untypedJiti = createJiti(ctx.options.rootDir, jitiOptions);
       const inputPath = resolve(ctx.options.rootDir, entry.input);
       let rawSchemaModule;
@@ -94,20 +85,15 @@ export async function typesBuild(ctx) {
         if (!output) continue;
         const fullOutputPath = resolve(distDir, output.fileName);
         writePromises.push(
-          writeFile(fullOutputPath, output.contents, "utf8").catch(
-            (writeError) => {
-              console.error(
-                `[untyped] Failed to write output file ${fullOutputPath} for entry '${entry.name}': ${writeError.message}`
-              );
-            }
-          )
+          writeFile(fullOutputPath, output.contents, "utf8").catch((writeError) => {
+            console.error(
+              `[untyped] Failed to write output file ${fullOutputPath} for entry '${entry.name}': ${writeError.message}`
+            );
+          })
         );
       }
       await Promise.all(writePromises);
-      relinka(
-        "verbose",
-        `[untyped] Generated outputs for '${entry.name}' in ${distDir}`
-      );
+      relinka("verbose", `[untyped] Generated outputs for '${entry.name}' in ${distDir}`);
     } catch (error) {
       console.error(
         `[untyped] Failed to process entry '${entry.name}': ${error.message}`,