@reliverse/dler 1.7.153 → 2.0.0

package/bin/impl/build/providers/rollup/plugins/esbuild.js

@@ -1,91 +0,0 @@
-import { extname, relative } from "@reliverse/pathkit";
-import { createFilter } from "@rollup/pluginutils";
-import { transform } from "esbuild";
-const DefaultLoaders = {
-  ".cjs": "js",
-  ".cts": "ts",
-  ".js": "js",
-  ".jsx": "jsx",
-  ".mjs": "js",
-  ".mts": "ts",
-  ".ts": "ts"
-  // ".tsx": "tsx", // todo: introduce new option in dler config which allows to enable/disable transpiling other extensions that .ts and .js (disabling is especially useful for bootstrapping projects clis like @reliverse/rse)
-};
-export function esbuild(options) {
-  const {
-    exclude = /node_modules/,
-    include = new RegExp(Object.keys(DefaultLoaders).join("|")),
-    loaders: loaderOptions,
-    ...transpileEsbuildOptions
-  } = options;
-  const loaders = { ...DefaultLoaders };
-  if (loaderOptions) {
-    for (const [key, value] of Object.entries(loaderOptions)) {
-      if (typeof value === "string") {
-        loaders[key] = value;
-      } else if (value === false) {
-        delete loaders[key];
-      }
-    }
-  }
-  const getLoader = (id = "") => {
-    return loaders[extname(id)];
-  };
-  const filter = createFilter(include, exclude);
-  return {
-    name: "transpileEsbuild",
-    async renderChunk(code, { fileName }) {
-      if (!options.minify) {
-        return null;
-      }
-      if (/\.d\.(c|m)?tsx?$/.test(fileName)) {
-        return null;
-      }
-      const loader = getLoader(fileName);
-      if (!loader) {
-        return null;
-      }
-      const result = await transform(code, {
-        ...transpileEsbuildOptions,
-        loader,
-        minify: true,
-        sourcefile: fileName
-      });
-      return {
-        code: result.code || "",
-        map: result.map || null
-      };
-    },
-    async transform(code, id) {
-      if (!filter(id)) {
-        return null;
-      }
-      const loader = getLoader(id);
-      if (!loader) {
-        return null;
-      }
-      const result = await transform(code, {
-        ...transpileEsbuildOptions,
-        loader,
-        sourcefile: id
-      });
-      printWarnings(id, result, this);
-      return {
-        code: result.code || "",
-        map: result.map || null
-      };
-    }
-  };
-}
-function printWarnings(id, result, plugin) {
-  if (result.warnings) {
-    for (const warning of result.warnings) {
-      let message = "[transpileEsbuild]";
-      if (warning.location) {
-        message += ` (${relative(process.cwd(), id)}:${warning.location.line}:${warning.location.column})`;
-      }
-      message += ` ${warning.text}`;
-      plugin.warn(message);
-    }
-  }
-}

package/bin/impl/build/providers/rollup/plugins/json.d.ts

@@ -1,3 +0,0 @@
-import type { RollupJsonOptions } from "@rollup/plugin-json";
-import type { Plugin } from "rollup";
-export declare function JSONPlugin(options: RollupJsonOptions): Plugin;

package/bin/impl/build/providers/rollup/plugins/json.js

@@ -1,17 +0,0 @@
-const jsonPluginModule = await import("@rollup/plugin-json");
-const jsonPlugin = jsonPluginModule.default || jsonPluginModule;
-const EXPORT_DEFAULT = "export default ";
-export function JSONPlugin(options) {
-  const plugin = jsonPlugin(options);
-  return {
-    ...plugin,
-    name: "dler-json",
-    transform(code, id) {
-      const res = plugin.transform.call(this, code, id);
-      if (res && typeof res !== "string" && "code" in res && res.code?.startsWith(EXPORT_DEFAULT)) {
-        res.code = res.code.replace(EXPORT_DEFAULT, "module.exports = ");
-      }
-      return res;
-    }
-  };
-}

package/bin/impl/build/providers/rollup/plugins/raw.d.ts

@@ -1,8 +0,0 @@
-import type { FilterPattern } from "@rollup/pluginutils";
-import type { Plugin } from "rollup";
-interface RawLoaderOptions {
-    exclude?: FilterPattern;
-    include?: FilterPattern;
-}
-export declare function rawPlugin(opts?: RawLoaderOptions): Plugin;
-export {};

package/bin/impl/build/providers/rollup/plugins/raw.js

@@ -1,20 +0,0 @@
-import { createFilter } from "@rollup/pluginutils";
-const defaults = {
-  exclude: [],
-  include: [/\.(md|txt|css|htm|html)$/]
-};
-export function rawPlugin(opts = {}) {
-  const options = { ...defaults, ...opts };
-  const filter = createFilter(options.include, options.exclude);
-  return {
-    name: "dler-raw",
-    transform(code, id) {
-      if (filter(id)) {
-        return {
-          code: `export default ${JSON.stringify(code)}`,
-          map: null
-        };
-      }
-    }
-  };
-}

package/bin/impl/build/providers/rollup/plugins/shebang.d.ts

@@ -1,5 +0,0 @@
-import type { Plugin } from "rollup";
-export declare function getShebang(code: string, append?: string): string;
-export declare function makeExecutable(filePath: string): Promise<void>;
-export declare function removeShebangPlugin(): Plugin;
-export declare function shebangPlugin(): Plugin;

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

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

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

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

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

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

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

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

package/bin/impl/build/providers/rollup/utils.js

@@ -1,38 +0,0 @@
-export const DEFAULT_EXTENSIONS = [
-  ".ts",
-  // ".tsx", // todo: introduce new option in dler config which allows to enable/disable transpiling other extensions that .ts and .js (disabling is especially useful for bootstrapping projects clis like @reliverse/rse)
-  ".mts",
-  ".cts",
-  ".mjs",
-  ".cjs",
-  ".js",
-  ".jsx",
-  ".json"
-];
-export function getChunkFilename(ctx, chunk, ext) {
-  if (chunk.isDynamicEntry) {
-    return `chunks/[name].${ext}`;
-  }
-  return `shared/${ctx.options.name}.[hash].${ext}`;
-}
-export function resolveAliases(ctx) {
-  const aliases = {
-    ...ctx.pkg.name ? { [ctx.pkg.name]: ctx.options.rootDir } : {},
-    ...ctx.options.alias
-  };
-  if (ctx.options.rollup.alias) {
-    if (Array.isArray(ctx.options.rollup.alias.entries)) {
-      Object.assign(
-        aliases,
-        Object.fromEntries(
-          ctx.options.rollup.alias.entries.map((entry) => {
-            return [entry.find, entry.replacement];
-          })
-        )
-      );
-    } else {
-      Object.assign(aliases, ctx.options.rollup.alias.entries || ctx.options.rollup.alias);
-    }
-  }
-  return aliases;
-}

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

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

package/bin/impl/build/providers/rollup/watch.js

@@ -1,30 +0,0 @@
-import { relative } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { watch as _rollupWatch } from "rollup";
-export function rollupWatch(rollupOptions) {
-  const transpileWatcher = _rollupWatch(rollupOptions);
-  let inputs;
-  if (Array.isArray(rollupOptions.input)) {
-    inputs = rollupOptions.input;
-  } else if (typeof rollupOptions.input === "string") {
-    inputs = [rollupOptions.input];
-  } else {
-    inputs = Object.keys(rollupOptions.input || {});
-  }
-  relinka(
-    "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");
-  transpileWatcher.on("change", (id, { event }) => {
-    relinka("verbose", `${relative(".", id)} was ${event}d`);
-  });
-  transpileWatcher.on("restart", () => {
-    relinka("verbose", "[dler] [rollup] Rebuilding bundle");
-  });
-  transpileWatcher.on("event", (event) => {
-    if (event.code === "END") {
-      relinka("success", "[dler] [rollup] Rebuild finished\n");
-    }
-  });
-}

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

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

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

@@ -1,111 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { resolve } from "@reliverse/pathkit";
-import { relinka } from "@reliverse/relinka";
-import { createJiti } from "jiti";
-import { pascalCase } from "scule";
-import { generateMarkdown, generateTypes, resolveSchema } from "untyped";
-import untypedPlugin from "untyped/babel-plugin";
-export async function typesBuild(ctx) {
-  const entries = ctx.options.entries.filter(
-    (entry) => entry.builder === "untyped"
-  );
-  if (entries.length === 0) {
-    return;
-  }
-  await ctx.hooks.callHook("untyped:entries", ctx, entries);
-  for (const entry of entries) {
-    try {
-      const distDir = entry.outDir;
-      if (!distDir) {
-        throw new Error(
-          `[untyped] Missing 'outDir' for entry '${entry.name}'. Please define an output directory.`
-        );
-      }
-      const jitiOptions = {
-        interopDefault: true,
-        transformOptions: {
-          babel: {
-            plugins: [untypedPlugin]
-          }
-        }
-      };
-      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;
-      try {
-        rawSchemaModule = await untypedJiti.import(inputPath);
-      } catch (importError) {
-        console.warn(
-          `[untyped] Failed to import schema for entry '${entry.name}' from ${inputPath}: ${importError.message}`
-        );
-        rawSchemaModule = {};
-      }
-      let rawSchema;
-      if (rawSchemaModule && typeof rawSchemaModule === "object" && "default" in rawSchemaModule && // Check if the default export itself is the intended schema object
-      typeof rawSchemaModule.default === "object" && rawSchemaModule.default !== null) {
-        rawSchema = rawSchemaModule.default;
-      } else if (typeof rawSchemaModule === "object" && rawSchemaModule !== null) {
-        rawSchema = rawSchemaModule;
-      } else {
-        console.warn(
-          `[untyped] Invalid schema input resolved for entry '${entry.name}' (path: ${entry.input}). Expected an object, got ${typeof rawSchemaModule}. Using empty schema.`
-        );
-        rawSchema = {};
-      }
-      const defaults = entry.defaults || {};
-      const schema = await resolveSchema(rawSchema, defaults);
-      await ctx.hooks.callHook("untyped:entry:schema", ctx, entry, schema);
-      const outputs = {
-        declaration: entry.declaration ? {
-          contents: generateTypes(schema, {
-            interfaceName: pascalCase(`${entry.name}-schema`)
-            // addDefaults: true, // TODO: Add JSDoc default values (allow to configure via reliverse.ts)
-            // addDescription: true, // TODO: Add JSDoc descriptions (allow to configure via reliverse.ts)
-          }),
-          fileName: `${entry.name}.d.ts`
-        } : void 0,
-        defaults: {
-          contents: JSON.stringify(defaults, null, 2),
-          fileName: `${entry.name}.defaults.json`
-        },
-        markdown: {
-          contents: generateMarkdown(schema),
-          fileName: `${entry.name}.md`
-        },
-        schema: {
-          contents: JSON.stringify(schema, null, 2),
-          fileName: `${entry.name}.schema.json`
-        }
-      };
-      await ctx.hooks.callHook("untyped:entry:outputs", ctx, entry, outputs);
-      await mkdir(distDir, { recursive: true });
-      const writePromises = [];
-      for (const output of Object.values(outputs)) {
-        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}`
-            );
-          })
-        );
-      }
-      await Promise.all(writePromises);
-      relinka("verbose", `[untyped] Generated outputs for '${entry.name}' in ${distDir}`);
-    } catch (error) {
-      console.error(
-        `[untyped] Failed to process entry '${entry.name}': ${error.message}`,
-        error.stack
-      );
-    }
-  }
-  await ctx.hooks.callHook("untyped:done", ctx);
-  if (entries.length > 0 && ctx.options.transpileWatch) {
-    relinka(
-      "warn",
-      "`untyped` builder does not support transpileWatch mode effectively (schema changes may require manual rebuild)."
-    );
-  }
-}

package/bin/impl/build/providers/utils.d.ts

@@ -1,19 +0,0 @@
-import type { PackageJson } from "pkg-types";
-import type { BuildContext, BuildPreset, UnifiedBuildConfig } from "../../types/mod.js";
-interface OutputDescriptor {
-    file: string;
-    type?: "cjs" | "esm";
-}
-export declare function arrayIncludes(arr: (RegExp | string)[], searchElement: string): boolean;
-export declare function dumpObject(obj: Record<string, any>): string;
-export declare function extractExportFilenames(exports: PackageJson["exports"], conditions?: string[]): OutputDescriptor[];
-export declare function getpkg(id?: string): string;
-export declare function inferPkgExternals(pkg: PackageJson): (RegExp | string)[];
-export declare function listRecursively(path: string): string[];
-export declare function removeExtension(filename: string): string;
-export declare function resolvePreset(preset: BuildPreset | string, rootDir: string): Promise<UnifiedBuildConfig>;
-export declare function rmdir(dir: string): Promise<void>;
-export declare function symlink(from: string, to: string, force?: boolean): Promise<void>;
-export declare function warn(ctx: BuildContext, message: string): void;
-export declare function withTrailingSlash(path: string): string;
-export {};