@reliverse/dler 1.2.0

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

@@ -0,0 +1,48 @@
+import { FixDtsDefaultCjsExportsPlugin } from "fix-dts-default-cjs-exports/rollup";
+import MagicString from "magic-string";
+import { findStaticImports } from "mlly";
+export function cjsPlugin() {
+  return {
+    name: "dler-cjs",
+    renderChunk(code, _chunk, opts) {
+      if (opts.format === "es") {
+        const result = CJSToESM(code);
+        return result || null;
+      }
+      return null;
+    }
+  };
+}
+export function fixCJSExportTypePlugin(ctx) {
+  const regexp = ctx.options.declaration === "node16" ? /\.d\.cts$/ : /\.d\.c?ts$/;
+  return FixDtsDefaultCjsExportsPlugin({
+    matcher: (info) => {
+      return info.type === "chunk" && info.exports?.length > 0 && info.exports.includes("default") && regexp.test(info.fileName) && info.isEntry;
+    },
+    warn: (msg) => ctx.warnings.add(msg)
+  });
+}
+const CJSyntaxRe = /__filename|__dirname|require\(|require\.resolve\(/;
+const CJSShim = `
+
+// -- dler CommonJS Shims --
+import __cjs_url__ from 'url';
+import __cjs_path__ from 'path';
+import __cjs_mod__ from 'module';
+const __filename = __cjs_url__.fileURLToPath(import.meta.url);
+const __dirname = __cjs_path__.dirname(__filename);
+const require = __cjs_mod__.createRequire(import.meta.url);
+`;
+function CJSToESM(code) {
+  if (code.includes(CJSShim) || !CJSyntaxRe.test(code)) {
+    return null;
+  }
+  const lastESMImport = findStaticImports(code).pop();
+  const indexToAppend = lastESMImport ? lastESMImport.end : 0;
+  const s = new MagicString(code);
+  s.appendRight(indexToAppend, CJSShim);
+  return {
+    code: s.toString(),
+    map: s.generateMap({ hires: true })
+  };
+}

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

@@ -0,0 +1,91 @@
+import { createFilter } from "@rollup/pluginutils";
+import { transform } from "esbuild";
+import { extname, relative } from "pathe";
+const DefaultLoaders = {
+  ".cjs": "js",
+  ".cts": "ts",
+  ".js": "js",
+  ".jsx": "jsx",
+  ".mjs": "js",
+  ".mts": "ts",
+  ".ts": "ts",
+  ".tsx": "tsx"
+};
+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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/json.js

@@ -0,0 +1,17 @@
+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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/raw.js

@@ -0,0 +1,20 @@
+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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/plugins/shebang.js

@@ -0,0 +1,42 @@
+import { promises as fsp } from "node:fs";
+import { resolve } from "pathe";
+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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/stub.js

@@ -0,0 +1,137 @@
+import { fileURLToPath, resolveModuleExportNames, resolvePath } from "mlly";
+import { promises as fsp } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, relative, resolve } from "pathe";
+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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/utils.js

@@ -0,0 +1,41 @@
+export const DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".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/libs/sdk/sdk-impl/build/bundlers/unified/rollup/watch.js

@@ -0,0 +1,33 @@
+import { relinka } from "@reliverse/relinka";
+import { relative } from "pathe";
+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(
+    "info",
+    `[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("info", `${relative(".", id)} was ${event}d`);
+  });
+  transpileWatcher.on("restart", () => {
+    relinka("info", "[dler] [rollup] Rebuilding bundle");
+  });
+  transpileWatcher.on("event", (event) => {
+    if (event.code === "END") {
+      relinka("success", "[dler] [rollup] Rebuild finished\n");
+    }
+  });
+}

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

@@ -0,0 +1,6 @@
+export function defineBuildConfig(config) {
+  return (Array.isArray(config) ? config : [config]).filter(Boolean);
+}
+export function definePreset(preset) {
+  return preset;
+}

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

@@ -0,0 +1,125 @@
+import { relinka } from "@reliverse/relinka";
+import { createJiti } from "jiti";
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "pathe";
+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 .config/dler.ts)
+            // addDescription: true, // TODO: Add JSDoc descriptions (allow to configure via .config/dler.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)."
+    );
+  }
+}