@reliverse/dler 1.7.91 → 1.7.93

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

@@ -0,0 +1,49 @@
+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/app/build/providers/mkdist/mkdist-impl/loader.d.ts

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

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

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

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

@@ -0,0 +1,12 @@
+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/app/build/providers/mkdist/mkdist-impl/loaders/postcss.d.ts

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

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

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

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

@@ -0,0 +1,31 @@
+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/app/build/providers/mkdist/mkdist-impl/loaders/vue.d.ts

@@ -0,0 +1,17 @@
+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/app/build/providers/mkdist/mkdist-impl/loaders/vue.js

@@ -0,0 +1,145 @@
+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/app/build/providers/mkdist/mkdist-impl/make.d.ts

@@ -0,0 +1,11 @@
+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/app/build/providers/mkdist/mkdist-impl/make.js

@@ -0,0 +1,192 @@
+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("success", "Build completed successfully!");
+  }
+  return {
+    result: {
+      errors,
+      writtenFiles
+    },
+    duration
+  };
+}

package/bin/app/build/providers/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 "../../../../../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;

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

@@ -0,0 +1,94 @@
+import { statSync } from "node:fs";
+import { resolve } from "@reliverse/pathkit";
+import { findDynamicImports, findExports, findStaticImports, findTypeExports } from "mlly";
+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/app/build/providers/mkdist/mkdist-impl/utils/vue-dts.d.ts

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