@reliverse/dler 1.7.153 → 2.0.0

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

@@ -1,49 +0,0 @@
-import { promises as fsp } from "node:fs";
-import { relative, resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-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/impl/build/providers/mkdist/mkdist-impl/loader.d.ts

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

package/bin/impl/build/providers/mkdist/mkdist-impl/loader.js

@@ -1,26 +0,0 @@
-import { resolveLoaders } from "./loaders/loaders-mod.js";
-export function createLoader(loaderOptions = {}) {
-  const loaders = resolveLoaders(loaderOptions.loaders);
-  const loadFile = async (input) => {
-    const context = {
-      loadFile,
-      options: loaderOptions
-    };
-    for (const loader of loaders) {
-      const outputs = await loader(input, context);
-      if (outputs?.length) {
-        return outputs;
-      }
-    }
-    return [
-      {
-        path: input.path,
-        srcPath: input.srcPath,
-        raw: true
-      }
-    ];
-  };
-  return {
-    loadFile
-  };
-}

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

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

package/bin/impl/build/providers/mkdist/mkdist-impl/loaders/js.js

@@ -1,50 +0,0 @@
-import { transform } from "esbuild";
-import jiti from "jiti";
-const DECLARATION_RE = /\.d\.[cm]?ts$/;
-const CM_LETTER_RE = /(?<=\.)(c|m)(?=[jt]s$)/;
-const KNOWN_EXT_RE = /\.(c|m)?[jt]sx?$/;
-const TS_EXTS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts"]);
-export const jsLoader = async (input, { options }) => {
-  if (!KNOWN_EXT_RE.test(input.path) || DECLARATION_RE.test(input.path)) {
-    return;
-  }
-  const output = [];
-  let contents = await input.getContents();
-  if (options.declaration && !input.srcPath?.match(DECLARATION_RE)) {
-    const cm = input.srcPath?.match(CM_LETTER_RE)?.[0] || "";
-    const extension2 = `.d.${cm}ts`;
-    output.push({
-      contents,
-      srcPath: input.srcPath,
-      path: input.path,
-      extension: extension2,
-      declaration: true
-    });
-  }
-  if (TS_EXTS.has(input.extension)) {
-    contents = await transform(contents, {
-      ...options.esbuild,
-      loader: "ts"
-    }).then((r) => r.code);
-  } else if (input.extension === ".jsx") {
-    contents = await transform(contents, {
-      // loader: input.extension === ".tsx" ? "tsx" : "jsx",
-      loader: "jsx",
-      ...options.esbuild
-    }).then((r) => r.code);
-  }
-  const isCjs = options.format === "cjs";
-  if (isCjs) {
-    contents = jiti("").transform({ source: contents, retainLines: false }).replace(/^exports.default = /gm, "module.exports = ").replace(/^var _default = exports.default = /gm, "module.exports = ").replace("module.exports = void 0;", "");
-  }
-  let extension = isCjs ? ".js" : ".mjs";
-  if (options.ext) {
-    extension = options.ext.startsWith(".") ? options.ext : `.${options.ext}`;
-  }
-  output.push({
-    contents,
-    path: input.path,
-    extension
-  });
-  return output;
-};

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

@@ -1,12 +0,0 @@
-import type { Loader } from "../../../../../types/mod.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/impl/build/providers/mkdist/mkdist-impl/loaders/loaders-mod.js

@@ -1,30 +0,0 @@
-import { jsLoader } from "./js.js";
-import { postcssLoader } from "./postcss.js";
-import { sassLoader } from "./sass.js";
-import { vueLoader } from "./vue.js";
-let cachedVueLoader;
-const loaders = {
-  js: jsLoader,
-  vue: cachedVueLoader || (async (...args) => {
-    cachedVueLoader = await import("vue-sfc-transformer/mkdist").then((r) => r.vueLoader).catch(() => vueLoader);
-    return cachedVueLoader(...args);
-  }),
-  sass: sassLoader,
-  postcss: postcssLoader
-};
-export const defaultLoaders = ["js", "vue", "sass", "postcss"];
-export function resolveLoader(loader) {
-  if (typeof loader === "string") {
-    return loaders[loader];
-  }
-  return loader;
-}
-export function resolveLoaders(loaders2 = defaultLoaders) {
-  return loaders2.map((loaderName) => {
-    const _loader = resolveLoader(loaderName);
-    if (!_loader) {
-      console.warn("Unknown loader:", loaderName);
-    }
-    return _loader;
-  }).filter(Boolean);
-}

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

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

package/bin/impl/build/providers/mkdist/mkdist-impl/loaders/postcss.js

@@ -1,28 +0,0 @@
-import autoprefixer from "autoprefixer";
-import cssnano from "cssnano";
-import postcss from "postcss";
-import postcssNested from "postcss-nested";
-export const postcssLoader = async (input, ctx) => {
-  if (ctx.options.postcss === false || ![".css"].includes(input.extension)) {
-    return;
-  }
-  const output = [];
-  const contents = await input.getContents();
-  const transformed = await postcss(
-    [
-      ctx.options.postcss?.nested !== false && postcssNested(ctx.options.postcss?.nested),
-      ctx.options.postcss?.autoprefixer !== false && autoprefixer(ctx.options.postcss?.autoprefixer),
-      ctx.options.postcss?.cssnano !== false && cssnano(ctx.options.postcss?.cssnano),
-      ...ctx.options.postcss?.plugins || []
-    ].filter(Boolean)
-  ).process(contents, {
-    ...ctx.options.postcss?.processOptions,
-    from: input.srcPath
-  });
-  output.push({
-    contents: transformed.content,
-    path: input.path,
-    extension: ".css"
-  });
-  return output;
-};

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

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

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

@@ -1,31 +0,0 @@
-import { pathToFileURL } from "node:url";
-import { basename } from "@reliverse/pathkit";
-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/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 "../../../../../types/mod.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;

package/bin/impl/build/providers/mkdist/mkdist-impl/loaders/vue.js

@@ -1,145 +0,0 @@
-let warnedTypescript = false;
-function defineVueLoader(options) {
-  const blockLoaders = options?.blockLoaders || {};
-  return async (input, context) => {
-    if (input.extension !== ".vue") {
-      return;
-    }
-    const { parse } = await import("vue/compiler-sfc");
-    let modified = false;
-    const raw = await input.getContents();
-    const sfc = parse(raw, {
-      filename: input.srcPath,
-      ignoreEmpty: true
-    });
-    if (sfc.errors.length > 0) {
-      for (const error of sfc.errors) {
-        console.error(error);
-      }
-      return;
-    }
-    const isTs = [sfc.descriptor.script?.lang, sfc.descriptor.scriptSetup?.lang].some(
-      (lang) => lang?.startsWith("ts")
-    );
-    if (isTs && !warnedTypescript) {
-      console.warn(
-        "[mkdist] vue-sfc-transformer is not installed. mkdist will not transform typescript syntax in Vue SFCs."
-      );
-      warnedTypescript = true;
-    }
-    const output = [];
-    const addOutput = (...files) => output.push(...files);
-    const blocks = [...sfc.descriptor.styles, ...sfc.descriptor.customBlocks].filter(
-      (item) => !!item
-    );
-    await context.loadFile({
-      path: `${input.path}.js`,
-      srcPath: `${input.srcPath}.js`,
-      extension: ".js",
-      getContents: () => "export default {}"
-    });
-    const results = await Promise.all(
-      blocks.map(async (data) => {
-        const blockLoader = blockLoaders[data.type];
-        const result = await blockLoader?.(data, {
-          ...context,
-          rawInput: input,
-          addOutput
-        });
-        if (result) {
-          modified = true;
-        }
-        return { block: result || data, offset: data.loc.start.offset };
-      })
-    );
-    if (!modified) {
-      return;
-    }
-    if (sfc.descriptor.template) {
-      results.unshift({
-        block: sfc.descriptor.template,
-        offset: sfc.descriptor.template.loc.start.offset
-      });
-    }
-    if (sfc.descriptor.script) {
-      results.unshift({
-        block: sfc.descriptor.script,
-        offset: sfc.descriptor.script.loc.start.offset
-      });
-    }
-    if (sfc.descriptor.scriptSetup) {
-      results.unshift({
-        block: sfc.descriptor.scriptSetup,
-        offset: sfc.descriptor.scriptSetup.loc.start.offset
-      });
-    }
-    const contents = results.sort((a, b) => a.offset - b.offset).map(({ block }) => {
-      const attrs = Object.entries(block.attrs).map(([key, value]) => {
-        if (!value) {
-          return;
-        }
-        return value === true ? key : `${key}="${value}"`;
-      }).filter((item) => !!item).join(" ");
-      const header = `<${`${block.type} ${attrs}`.trim()}>`;
-      const footer = `</${block.type}>`;
-      return `${header}
-${block.content.trim()}
-${footer}
-`;
-    }).join("\n");
-    addOutput({
-      path: input.path,
-      srcPath: input.srcPath,
-      extension: ".vue",
-      contents,
-      declaration: false
-    });
-    return output;
-  };
-}
-function defineDefaultBlockLoader(options) {
-  return async (block, { loadFile, rawInput, addOutput }) => {
-    if (options.type !== block.type) {
-      return;
-    }
-    const lang = typeof block.attrs.lang === "string" ? block.attrs.lang : options.outputLang;
-    const extension = `.${lang}`;
-    const files = await loadFile({
-      getContents: () => block.content,
-      path: `${rawInput.path}${extension}`,
-      srcPath: `${rawInput.srcPath}${extension}`,
-      extension
-    }) || [];
-    const blockOutputFile = files.find(
-      (f) => f.extension === `.${options.outputLang}` || options.validExtensions?.includes(f.extension)
-    );
-    if (!blockOutputFile) {
-      return;
-    }
-    addOutput(...files.filter((f) => f !== blockOutputFile));
-    return {
-      type: block.type,
-      attrs: toOmit(block.attrs, "lang"),
-      content: blockOutputFile.contents
-    };
-  };
-}
-const styleLoader = defineDefaultBlockLoader({
-  outputLang: "css",
-  type: "style"
-});
-export const fallbackVueLoader = defineVueLoader({
-  blockLoaders: {
-    style: styleLoader
-  }
-});
-let cachedVueLoader;
-export const vueLoader = async (file, ctx) => {
-  if (!cachedVueLoader) {
-    cachedVueLoader = await import("vue-sfc-transformer/mkdist").then((r) => r.vueLoader).catch(() => fallbackVueLoader);
-  }
-  return cachedVueLoader(file, ctx);
-};
-function toOmit(record, toRemove) {
-  return Object.fromEntries(Object.entries(record).filter(([key]) => key !== toRemove));
-}

package/bin/impl/build/providers/mkdist/mkdist-impl/make.d.ts

@@ -1,11 +0,0 @@
-import type { MkdistOptions } from "../../../../types/mod.js";
-export declare function mkdist(options?: MkdistOptions): Promise<{
-    result: {
-        errors: {
-            filename: string;
-            errors: TypeError[];
-        }[];
-        writtenFiles: string[];
-    };
-    duration: number;
-}>;

package/bin/impl/build/providers/mkdist/mkdist-impl/make.js

@@ -1,192 +0,0 @@
-import fsp from "node:fs/promises";
-import { basename, dirname, extname, join, resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import defu from "defu";
-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 = {}) {
-  const startTime = Date.now();
-  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) {
-    relinka("verbose", "Cleaning distribution directory...");
-    await fsp.unlink(options.distDir).catch(() => {
-    });
-    await fsp.rm(options.distDir, { recursive: true, force: true });
-    await fsp.mkdir(options.distDir, { recursive: true });
-  }
-  relinka("verbose", "Scanning input files...");
-  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" })
-    };
-  });
-  relinka("verbose", `Found ${files.length} files to process`);
-  options.typescript ||= {};
-  if (options.typescript.compilerOptions) {
-    relinka("verbose", "Normalizing TypeScript compiler options...");
-    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
-    }
-  );
-  relinka("verbose", "Creating file loaders...");
-  const { loadFile } = createLoader(options);
-  relinka("verbose", "Processing files with loaders...");
-  const outputs = [];
-  let processedCount = 0;
-  await Promise.all(
-    files.map(async (file) => {
-      const result = await loadFile(file);
-      if (result) {
-        outputs.push(...result);
-      }
-      processedCount++;
-    })
-  );
-  relinka("verbose", "Normalizing output extensions...");
-  const pathConflicts = [];
-  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);
-    const conflictingOutput = outputs.find((o) => o !== output && o.path === output.path);
-    if (conflictingOutput) {
-      pathConflicts.push(output.path);
-    }
-  }
-  if (pathConflicts.length > 0) {
-    const errorMessage = `Output path conflict detected for paths: ${pathConflicts.join(", ")}. Multiple files would write to the same output path.`;
-    relinka("error", errorMessage);
-    throw new Error(errorMessage);
-  }
-  const dtsOutputs = outputs.filter((o) => o.declaration && !o.skip);
-  if (dtsOutputs.length > 0) {
-    relinka("verbose", `Generating TypeScript declarations for ${dtsOutputs.length} files...`);
-    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));
-    }
-    let dtsProcessed = 0;
-    for (const output of dtsOutputs) {
-      const result = declarations[output.srcPath];
-      output.contents = result?.contents || "";
-      if (result.errors) {
-        output.errors = result.errors;
-      }
-      dtsProcessed++;
-    }
-  }
-  relinka("verbose", "Resolving relative imports...");
-  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"];
-  const esmOutputs = outputs.filter((o) => o.extension === ".mjs" || o.extension === ".js");
-  for (const output of esmOutputs) {
-    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"];
-  const cjsOutputs = outputs.filter((o) => o.extension === ".cjs");
-  for (const output of cjsOutputs) {
-    output.contents = output.contents.replace(
-      /require\((["'])(.*)(["'])\)/g,
-      (_, head, id, tail) => "require(" + head + resolveId(output.path, id, cjsResolveExtensions) + tail + ")"
-    );
-  }
-  const outputsToWrite = outputs.filter((o) => !o.skip);
-  relinka("verbose", `Writing ${outputsToWrite.length} output files...`);
-  const writtenFiles = [];
-  const errors = [];
-  let writtenCount = 0;
-  await Promise.all(
-    outputsToWrite.map(async (output) => {
-      try {
-        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 });
-        }
-      } catch (error) {
-        const errorMessage = `Failed to write file ${output.path}: ${error instanceof Error ? error.message : "Unknown error"}`;
-        errors.push({
-          filename: output.path,
-          errors: [new TypeError(errorMessage)]
-        });
-      }
-      writtenCount++;
-    })
-  );
-  const duration = Date.now() - startTime;
-  if (errors.length > 0) {
-    relinka("warn", `Build completed with ${errors.length} errors`);
-    for (const error of errors.slice(0, 5)) {
-      relinka(
-        "error",
-        `Error in ${error.filename}: ${error.errors[0]?.message || "Unknown error"}`
-      );
-    }
-    if (errors.length > 5) {
-      relinka("error", `... and ${errors.length - 5} more errors`);
-    }
-  } else {
-    relinka("verbose", "Build completed successfully!");
-  }
-  return {
-    result: {
-      errors,
-      writtenFiles
-    },
-    duration
-  };
-}

package/bin/impl/build/providers/mkdist/mkdist-impl/utils/dts.d.ts

@@ -1,11 +0,0 @@
-import type { TSConfig } from "pkg-types";
-import type { CompilerHost, EmitResult } from "typescript";
-import type { MkdistOptions } from "../../../../../types/mod.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;