@reliverse/dler 1.7.91 → 1.7.93

package/bin/libs/sdk/sdk-impl/build/providers/build.js

@@ -1,351 +0,0 @@
-import { isAbsolute, normalize, relative, resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { defu } from "defu";
-import { createHooks } from "hookable";
-import { createJiti } from "jiti";
-import { promises as fsp } from "node:fs";
-import Module from "node:module";
-import prettyBytes from "pretty-bytes";
-import prettyMilliseconds from "pretty-ms";
-import { glob } from "tinyglobby";
-import { createPerfTimer, getElapsedPerfTime } from "../../utils/utils-perf.js";
-import { copyBuild } from "./copy/copy-mod.js";
-import { mkdistBuild } from "./mkdist/mkdist-mod.js";
-import { rollupBuild } from "./rollup/build.js";
-import { typesBuild } from "./untyped/untyped-mod.js";
-import {
-  dumpObject,
-  inferPkgExternals,
-  removeExtension,
-  resolvePreset,
-  rmdir,
-  withTrailingSlash
-} from "./utils.js";
-import { validateDependencies, validatePackage } from "./validate.js";
-const STOP_AFTER_STEP = 0;
-function shouldStopAtStep(stepNumber) {
-  if (STOP_AFTER_STEP > 0 && stepNumber >= STOP_AFTER_STEP) {
-    relinka("success", `Stopping build at step ${stepNumber}`);
-    process.exit(0);
-  }
-}
-export async function unifiedBuild(inputSourceDir, coreIsCLI, isLib, rootDir, inputConfig, outDir, transpileStub = false) {
-  shouldStopAtStep(1);
-  relinka("info", "Starting unified build process...");
-  relinka("verbose", `Processing build for source directory: ${inputSourceDir}`);
-  relinka(
-    "verbose",
-    `Output directory: ${outDir}, Is CLI: ${coreIsCLI.enabled}, Is Library: ${isLib}`
-  );
-  const resolvedRootDir = resolve(process.cwd(), rootDir || ".");
-  const jiti = createJiti(resolvedRootDir);
-  const _buildConfig = await jiti.import(inputConfig?.config || ".config/dler.ts", {
-    default: true,
-    try: !inputConfig.config
-  }) || {};
-  const buildConfigs = (Array.isArray(_buildConfig) ? _buildConfig : [_buildConfig]).filter(
-    Boolean
-  );
-  const pkg = await jiti.import("./package.json", {
-    default: true,
-    try: true
-  }) || {};
-  const cleanedDirs = [];
-  const _transpileWatchMode = inputConfig.transpileWatch === true;
-  const _transpileStubMode = !_transpileWatchMode && (transpileStub || inputConfig.transpileStub === true);
-  if (!_transpileWatchMode && !_transpileStubMode) {
-    Object.assign(pkg, pkg.publishConfig);
-  }
-  for (const buildConfig of buildConfigs) {
-    await _build(
-      resolvedRootDir,
-      inputConfig,
-      buildConfig,
-      pkg,
-      cleanedDirs,
-      _transpileStubMode,
-      _transpileWatchMode,
-      outDir,
-      inputConfig.showOutLog || true,
-      isLib
-    );
-  }
-}
-async function _build(rootDir, inputConfig, buildConfig, pkg, cleanedDirs, _transpileStubMode, _transpileWatchMode, outDir, showOutLog, isLib) {
-  const timer = createPerfTimer();
-  relinka("info", "Resolving build configuration...");
-  const preset = await resolvePreset(
-    buildConfig.preset || pkg.dler?.preset || pkg.build?.preset || inputConfig.preset || "auto",
-    rootDir
-  );
-  const options = defu(buildConfig, pkg.dler || pkg.build, inputConfig, preset, {
-    alias: {},
-    clean: false,
-    declaration: void 0,
-    dependencies: [],
-    devDependencies: [],
-    entries: [],
-    externals: [...Module.builtinModules, ...Module.builtinModules.map((m) => `node:${m}`)],
-    transpileFailOnWarn: true,
-    name: (pkg?.name || "").split("/").pop() || "default",
-    outDir,
-    parallel: false,
-    peerDependencies: [],
-    replace: {},
-    rollup: {
-      alias: {},
-      cjsBridge: false,
-      commonjs: {
-        ignoreTryCatch: true
-      },
-      dts: {
-        compilerOptions: {
-          /**
-           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/127
-           */
-          composite: false,
-          /**
-           * @see https://github.com/Swatinem/rollup-plugin-dts/issues/143
-           */
-          preserveSymlinks: false
-        },
-        respectExternal: true
-      },
-      emitCJS: false,
-      esbuild: { target: "esnext" },
-      inlineDependencies: false,
-      json: {
-        preferConst: true
-      },
-      output: {
-        /**
-         * @see https://v8.dev/features/import-attributes
-         */
-        importAttributesKey: "with"
-      },
-      preserveDynamicImports: true,
-      // Plugins
-      replace: {
-        preventAssignment: true
-      },
-      resolve: {
-        preferBuiltins: true
-      },
-      watch: false
-    },
-    rootDir,
-    showOutLog: true,
-    transpileSourcemap: false,
-    transpileStub: _transpileStubMode,
-    transpileStubOptions: {
-      /**
-       * @see https://github.com/unjs/jiti#%EF%B8%8F-options
-       */
-      jiti: {
-        alias: {},
-        interopDefault: true
-      }
-    },
-    transpileWatch: _transpileWatchMode,
-    transpileWatchOptions: _transpileWatchMode ? {
-      exclude: "node_modules/**",
-      include: "src/**"
-    } : void 0,
-    isLib
-  });
-  shouldStopAtStep(5);
-  relinka("verbose", "Build-specific configuration merged with defaults");
-  relinka("verbose", `Build options: clean=${options.clean}, parallel=${options.parallel}`);
-  relinka("verbose", `Declaration files: ${options.declaration ? "enabled" : "disabled"}`);
-  options.outDir = resolve(options.rootDir, options.outDir);
-  const jiti = createJiti(options.rootDir, { interopDefault: true });
-  relinka("info", "Initializing build context...");
-  const ctx = {
-    buildEntries: [],
-    hooks: createHooks(),
-    jiti,
-    options,
-    pkg,
-    usedImports: /* @__PURE__ */ new Set(),
-    warnings: /* @__PURE__ */ new Set(),
-    isLib
-  };
-  if (preset.hooks) {
-    ctx.hooks.addHooks(preset.hooks);
-  }
-  if (inputConfig.hooks) {
-    ctx.hooks.addHooks(inputConfig.hooks);
-  }
-  if (buildConfig.hooks) {
-    ctx.hooks.addHooks(buildConfig.hooks);
-  }
-  await ctx.hooks.callHook("build:prepare", ctx);
-  relinka("info", "Processing build entries...");
-  options.entries = options.entries.map(
-    (entry) => typeof entry === "string" ? { input: entry, isLib } : entry
-  );
-  for (const entry of options.entries) {
-    if (typeof entry.name !== "string") {
-      let relativeInput = isAbsolute(entry.input) ? relative(rootDir, entry.input) : normalize(entry.input);
-      if (relativeInput.startsWith("./")) {
-        relativeInput = relativeInput.slice(2);
-      }
-      entry.name = removeExtension(relativeInput.replace(/^src\//, ""));
-    }
-    if (!entry.input) {
-      throw new Error(`Missing entry input: ${dumpObject(entry)}`);
-    }
-    if (!entry.builder) {
-      entry.builder = entry.input.endsWith("/") ? "mkdist" : "rollup";
-    }
-    if (options.declaration !== void 0 && entry.declaration === void 0) {
-      entry.declaration = options.declaration;
-    }
-    entry.input = resolve(options.rootDir, entry.input);
-    entry.outDir = resolve(options.rootDir, entry.outDir || options.outDir);
-    entry.isLib = isLib;
-  }
-  options.dependencies = Object.keys(pkg.dependencies || {});
-  options.peerDependencies = Object.keys(pkg.peerDependencies || {});
-  options.devDependencies = Object.keys(pkg.devDependencies || {});
-  options.externals.push(...inferPkgExternals(pkg));
-  options.externals = [...new Set(options.externals)];
-  await ctx.hooks.callHook("build:before", ctx);
-  relinka(
-    "verbose",
-    `${options.transpileStub ? "Stubbing" : "[unified] Building"} ${options.name}`
-  );
-  if (process.env.DEBUG) {
-    relinka(
-      "log",
-      `Root dir: ${options.rootDir}
-Entries:
-${options.entries.map((entry) => `  ${dumpObject(entry)}`).join("\n  ")}
-`
-    );
-  }
-  if (options.clean) {
-    relinka("info", "Cleaning output directories...");
-    for (const dir of new Set(
-      options.entries.map((e) => e.outDir).filter((p) => !!p).sort()
-    )) {
-      if (dir === options.rootDir || options.rootDir.startsWith(withTrailingSlash(dir)) || cleanedDirs.some((c) => dir.startsWith(c))) {
-        continue;
-      }
-      cleanedDirs.push(dir);
-      relinka("verbose", `Cleaning dist directory: \`./${relative(process.cwd(), dir)}\``);
-      await rmdir(dir);
-      await fsp.mkdir(dir, { recursive: true });
-    }
-  }
-  const buildTasks = [
-    { name: "Type generation", task: typesBuild },
-    { name: "mkdist build", task: mkdistBuild },
-    { name: "Rollup build", task: rollupBuild },
-    { name: "Copy files", task: copyBuild }
-  ];
-  const activeTasks = buildTasks.filter(({ task }) => {
-    if (task === typesBuild) return options.entries.some((e) => e.builder === "untyped");
-    if (task === mkdistBuild) return options.entries.some((e) => e.builder === "mkdist");
-    if (task === rollupBuild) return options.entries.some((e) => e.builder === "rollup");
-    if (task === copyBuild) return options.entries.some((e) => e.builder === "copy");
-    return false;
-  });
-  if (activeTasks.length === 0) {
-    relinka("info", "No build tasks to execute");
-  } else {
-    if (options.parallel) {
-      relinka("info", `Running ${activeTasks.length} build tasks in parallel...`);
-      await Promise.all(
-        activeTasks.map(async ({ task }) => {
-          await task(ctx);
-        })
-      );
-    } else {
-      for (const { task, name } of activeTasks) {
-        relinka("info", `Running ${name}...`);
-        await task(ctx);
-      }
-    }
-  }
-  if (options.transpileStub || options.transpileWatch) {
-    await ctx.hooks.callHook("build:done", ctx);
-    return;
-  }
-  relinka("info", "Finalizing build output...");
-  relinka("success", `Build succeeded for ${options.name}`);
-  const outFiles = await glob(["**"], { cwd: options.outDir });
-  for (const file of outFiles) {
-    let entry = ctx.buildEntries.find((e) => e.path === file);
-    if (!entry) {
-      entry = {
-        chunk: true,
-        path: file,
-        isLib: ctx.options.isLib
-      };
-      ctx.buildEntries.push(entry);
-    }
-    if (!entry.bytes) {
-      const stat = await fsp.stat(resolve(options.outDir, file));
-      entry.bytes = stat.size;
-    }
-  }
-  const rPath = (p) => relative(process.cwd(), resolve(options.outDir, p));
-  if (showOutLog) {
-    for (const entry of ctx.buildEntries.filter((e) => !e.chunk)) {
-      let totalBytes = entry.bytes || 0;
-      for (const chunk of entry.chunks || []) {
-        totalBytes += ctx.buildEntries.find((e) => e.path === chunk)?.bytes || 0;
-      }
-      let line = `  ${rPath(entry.path)} (${[
-        totalBytes && `total size: ${prettyBytes(totalBytes)}`,
-        entry.bytes && `chunk size: ${prettyBytes(entry.bytes)}`,
-        entry.exports?.length && `exports: ${entry.exports.join(", ")}`
-      ].filter(Boolean).join(", ")})`;
-      if (entry.chunks?.length) {
-        line += `
-${entry.chunks.map((p) => {
-          const chunk = ctx.buildEntries.find((e) => e.path === p) || {};
-          return `  \u2514\u2500 ${rPath(p)}${chunk.bytes ? ` (${prettyBytes(chunk.bytes)})` : ""}`;
-        }).join("\n")}`;
-      }
-      if (entry.modules?.length) {
-        line += `
-${entry.modules.filter((m) => m.id.includes("node_modules")).sort((a, b) => (b.bytes || 0) - (a.bytes || 0)).map((m) => {
-          return `  \u{1F4E6} ${rPath(m.id)}${m.bytes ? ` (${prettyBytes(m.bytes)})` : ""}`;
-        }).join("\n")}`;
-      }
-      relinka("verbose", entry.chunk ? line : line);
-    }
-    const elapsedTime = getElapsedPerfTime(timer);
-    const transpileFormattedTime = prettyMilliseconds(elapsedTime, {
-      verbose: true
-    });
-    const totalSize = ctx.buildEntries.reduce((a, e) => a + (e.bytes || 0), 0);
-    relinka("info", `Build complete! ${prettyBytes(totalSize)} in ${transpileFormattedTime}`);
-    relinka(
-      "info",
-      `\u03A3 Total dist size: ${prettyBytes(totalSize)} (build time: ${transpileFormattedTime})`
-    );
-  }
-  validateDependencies(ctx);
-  validatePackage(pkg, rootDir, ctx);
-  await ctx.hooks.callHook("build:done", ctx);
-  if (ctx.warnings.size > 0) {
-    relinka("warn", `Build completed with ${ctx.warnings.size} warnings`);
-    relinka(
-      "warn",
-      `Build is done with some warnings:
-${[...ctx.warnings].map((msg) => `- ${msg}`).join("\n")}`
-    );
-    if (ctx.options.transpileFailOnWarn) {
-      relinka(
-        "error",
-        "Exiting with code (1). You can change this behavior by setting `transpileFailOnWarn: false` ."
-      );
-      process.exit(1);
-    }
-    shouldStopAtStep(15);
-    relinka("info", `Build complete (with ${ctx.warnings.size} warnings)`);
-  }
-}

package/bin/libs/sdk/sdk-impl/build/providers/bun/single-file.js

@@ -1,133 +0,0 @@
-import { join } from "@reliverse/pathkit";
-import { existsSync, mkdir, rm } from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-const TARGETS = [
-  { platform: "linux", arch: "x64", extension: "", target: "bun-linux-x64" },
-  { platform: "linux", arch: "x64-baseline", extension: "", target: "bun-linux-x64-baseline" },
-  { platform: "linux", arch: "x64-modern", extension: "", target: "bun-linux-x64-modern" },
-  { platform: "linux", arch: "arm64", extension: "", target: "bun-linux-arm64" },
-  { platform: "linux", arch: "x64-musl", extension: "", target: "bun-linux-x64-musl" },
-  { platform: "linux", arch: "arm64-musl", extension: "", target: "bun-linux-arm64-musl" },
-  { platform: "windows", arch: "x64", extension: ".exe", target: "bun-windows-x64" },
-  {
-    platform: "windows",
-    arch: "x64-baseline",
-    extension: ".exe",
-    target: "bun-windows-x64-baseline"
-  },
-  { platform: "windows", arch: "x64-modern", extension: ".exe", target: "bun-windows-x64-modern" },
-  { platform: "darwin", arch: "x64", extension: "", target: "bun-darwin-x64" },
-  { platform: "darwin", arch: "arm64", extension: "", target: "bun-darwin-arm64" }
-];
-export const getOutputFileName = (target, baseName, isCompiled) => {
-  const suffix = target.arch === "x64" ? "" : `-${target.arch}`;
-  const extension = isCompiled ? target.extension : ".js";
-  return `${baseName}-${target.platform}${suffix}${extension}`;
-};
-export const buildForTarget = async (target, inputFile, options) => {
-  const outputFile = join(options.outdir, getOutputFileName(target, "dler", options.compile));
-  const buildArgs = [
-    "build",
-    ...options.compile ? ["--compile", `--target=${target.target}`] : [],
-    inputFile,
-    `--outfile=${outputFile}`
-  ];
-  if (options.minify) {
-    buildArgs.push("--minify");
-  }
-  if (options.sourcemap) {
-    buildArgs.push("--sourcemap");
-  }
-  if (options.bytecode) {
-    buildArgs.push("--bytecode");
-  }
-  if (options.assetNaming !== "[name]-[hash].[ext]") {
-    buildArgs.push(`--asset-naming=${options.assetNaming}`);
-  }
-  if (options.external && options.external.length > 0) {
-    for (const ext of options.external) {
-      buildArgs.push(`--external=${ext}`);
-    }
-  }
-  if (target.platform === "windows") {
-    if (options.windowsIcon && existsSync(options.windowsIcon)) {
-      buildArgs.push(`--windows-icon=${options.windowsIcon}`);
-    }
-    if (options.windowsHideConsole) {
-      buildArgs.push("--windows-hide-console");
-    }
-  }
-  relinka("info", `Building for ${target.platform}-${target.arch}...`);
-  try {
-    const proc = Bun.spawn(["bun", ...buildArgs], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text()
-    ]);
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      relinka("error", `Build failed for ${target.platform}-${target.arch}:`);
-      if (stderr) relinka("error", stderr);
-      if (stdout) relinka("error", stdout);
-      throw new Error(`Build failed with exit code ${exitCode}`);
-    }
-    relinka("success", `\u2705 Built: ${outputFile}`);
-    if (stdout.includes("bundle")) {
-      const bundleMatch = stdout.match(/bundle (\d+) modules/);
-      const compileMatch = stdout.match(/compile .* \[(\d+ms)\]/);
-      if (bundleMatch || compileMatch) {
-        const bundleInfo = bundleMatch ? `${bundleMatch[1]} modules` : "";
-        const compileInfo = compileMatch ? `${compileMatch[1]}` : "";
-        relinka("verbose", `  ${bundleInfo} ${compileInfo}`.trim());
-      }
-    }
-  } catch (error) {
-    relinka("error", `Failed to build for ${target.platform}-${target.arch}: ${error}`);
-    throw error;
-  }
-};
-export const cleanOutputDir = async (outdir) => {
-  if (existsSync(outdir)) {
-    relinka("info", `Cleaning output directory: ${outdir}`);
-    await rm(outdir, { recursive: true, force: true });
-  }
-  await mkdir(outdir, { recursive: true });
-};
-export const validateInputFile = (inputFile) => {
-  if (!existsSync(inputFile)) {
-    throw new Error(`Input file not found: ${inputFile}`);
-  }
-};
-export const parseTargets = (targetStr) => {
-  if (targetStr === "all") {
-    return TARGETS;
-  }
-  const requestedTargets = targetStr.split(",").map((t) => t.trim());
-  const validTargets = [];
-  for (const requested of requestedTargets) {
-    const exactMatch = TARGETS.find(
-      (target) => target.target === requested || `${target.platform}-${target.arch}` === requested || target.platform === requested
-    );
-    if (exactMatch) {
-      validTargets.push(exactMatch);
-      continue;
-    }
-    const platformTargets = TARGETS.filter((t) => t.platform === requested);
-    if (platformTargets.length > 0) {
-      validTargets.push(...platformTargets);
-    } else {
-      relinka("warn", `Unknown target: ${requested}`);
-    }
-  }
-  return validTargets.length > 0 ? validTargets : [TARGETS[0]];
-};
-export const listAvailableTargets = () => {
-  relinka("info", "Available targets:");
-  for (const target of TARGETS) {
-    const name = `${target.platform}-${target.arch}`;
-    relinka("info", `  ${target.target.padEnd(25)} (${name})`);
-  }
-};

package/bin/libs/sdk/sdk-impl/build/providers/copy/copy-mod.d.ts

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

package/bin/libs/sdk/sdk-impl/build/providers/copy/copy-mod.js

@@ -1,49 +0,0 @@
-import { relative, resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { promises as fsp } from "node:fs";
-import { glob } from "tinyglobby";
-import { rmdir, symlink, warn } from "../utils.js";
-const copy = fsp.cp || fsp.copyFile;
-export async function copyBuild(ctx) {
-  const entries = ctx.options.entries.filter((e) => e.builder === "copy");
-  await ctx.hooks.callHook("copy:entries", ctx, entries);
-  for (const entry of entries) {
-    const distDir = entry.outDir || entry.input;
-    if (!distDir || !entry.input) {
-      warn(ctx, "Missing required outDir or input for copy entry");
-      continue;
-    }
-    if (ctx.options.transpileStub) {
-      await rmdir(distDir);
-      await symlink(entry.input, distDir);
-    } else {
-      const patterns = Array.isArray(entry.pattern) ? entry.pattern : [entry.pattern || "**"];
-      const paths = await glob(patterns, {
-        absolute: false,
-        cwd: resolve(ctx.options.rootDir, entry.input)
-      });
-      const outputList = await Promise.allSettled(
-        paths.map(async (path) => {
-          const src = resolve(ctx.options.rootDir, entry.input, path);
-          const dist = resolve(ctx.options.rootDir, distDir, path);
-          await copy(src, dist);
-          return dist;
-        })
-      );
-      for (const output of outputList) {
-        if (output.status === "rejected") {
-          warn(ctx, output.reason);
-        }
-      }
-      ctx.buildEntries.push({
-        chunks: outputList.filter(({ status }) => status === "fulfilled").map((p) => relative(ctx.options.outDir, p.value)),
-        path: distDir,
-        isLib: entry.isLib
-      });
-    }
-  }
-  await ctx.hooks.callHook("copy:done", ctx);
-  if (entries.length > 0 && ctx.options.transpileWatch) {
-    relinka("warn", "`untyped` builder does not support transpileWatch mode yet.");
-  }
-}

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loader.d.ts

@@ -1,4 +0,0 @@
-import type { CreateLoaderOptions } from "../../../../sdk-types.js";
-export declare function createLoader(loaderOptions?: CreateLoaderOptions): {
-    loadFile: LoadFile;
-};

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/js.d.ts

@@ -1,2 +0,0 @@
-import type { Loader } from "../../../../../sdk-types.js";
-export declare const jsLoader: Loader;

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/loaders-mod.d.ts

@@ -1,12 +0,0 @@
-import type { Loader } from "../../../../../sdk-types.js";
-declare const loaders: {
-    js: Loader;
-    vue: any;
-    sass: Loader;
-    postcss: Loader;
-};
-type LoaderName = keyof typeof loaders;
-export declare const defaultLoaders: LoaderName[];
-export declare function resolveLoader(loader: LoaderName | Loader): any;
-export declare function resolveLoaders(loaders?: (LoaderName | Loader)[]): Loader[];
-export {};

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/postcss.d.ts

@@ -1,3 +0,0 @@
-import type { Loader } from "../../../../../sdk-types.js";
-export type PostcssLoaderOptions = {};
-export declare const postcssLoader: Loader;

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/sass.d.ts

@@ -1,2 +0,0 @@
-import type { Loader } from "../../../../../sdk-types.js";
-export declare const sassLoader: Loader;

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/sass.js

@@ -1,31 +0,0 @@
-import { basename } from "@reliverse/pathkit";
-import { pathToFileURL } from "node:url";
-export const sassLoader = async (input) => {
-  if (![".sass", ".scss"].includes(input.extension)) {
-    return;
-  }
-  if (basename(input.srcPath).startsWith("_")) {
-    return [
-      {
-        contents: "",
-        path: input.path,
-        skip: true
-      }
-    ];
-  }
-  const compileString = await import("sass").then(
-    (r) => r.compileString || r.default.compileString
-  );
-  const output = [];
-  const contents = await input.getContents();
-  output.push({
-    contents: compileString(contents, {
-      loadPaths: ["node_modules"],
-      // @ts-expect-error TODO: fix ts
-      url: pathToFileURL(input.srcPath)
-    }).css,
-    path: input.path,
-    extension: ".css"
-  });
-  return output;
-};

package/bin/libs/sdk/sdk-impl/build/providers/mkdist/mkdist-impl/loaders/vue.d.ts

@@ -1,17 +0,0 @@
-import type { SFCBlock } from "vue/compiler-sfc";
-import type { InputFile, Loader, LoaderContext, OutputFile } from "../../../../../sdk-types.js";
-export interface DefineVueLoaderOptions {
-    blockLoaders?: Record<string, VueBlockLoader | undefined>;
-}
-export type VueBlock = Pick<SFCBlock, "type" | "content" | "attrs">;
-export type VueBlockLoader = (block: VueBlock, context: LoaderContext & {
-    rawInput: InputFile;
-    addOutput: (...files: OutputFile[]) => void;
-}) => Promise<VueBlock | undefined>;
-export interface DefaultBlockLoaderOptions {
-    type: "script" | "style" | "template";
-    outputLang: string;
-    validExtensions?: string[];
-}
-export declare const fallbackVueLoader: Loader;
-export declare const vueLoader: Loader;