@reliverse/dler 1.7.91 → 1.7.93

package/bin/libs/sdk/sdk-impl/utils/spinner.js

@@ -1,53 +0,0 @@
-export class SimpleSpinner {
-  interval;
-  message;
-  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  currentFrame = 0;
-  isSpinning = false;
-  constructor(message) {
-    this.message = message;
-  }
-  start() {
-    if (this.isSpinning || !process.stdout.isTTY) {
-      return this;
-    }
-    this.isSpinning = true;
-    process.stdout.write("\x1B[?25l");
-    this.interval = setInterval(() => {
-      const frame = this.frames[this.currentFrame];
-      process.stdout.write(`\r${frame} ${this.message}`);
-      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
-    }, 80);
-    return this;
-  }
-  stop(finalMessage) {
-    if (!this.isSpinning) {
-      return this;
-    }
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = void 0;
-    }
-    this.isSpinning = false;
-    process.stdout.write("\r\x1B[K");
-    process.stdout.write("\x1B[?25h");
-    if (finalMessage) {
-      process.stdout.write(`${finalMessage}
-`);
-    }
-    return this;
-  }
-  updateMessage(message) {
-    this.message = message;
-    return this;
-  }
-  succeed(message) {
-    return this.stop(message ? `\u2705 ${message}` : `\u2705 ${this.message}`);
-  }
-  fail(message) {
-    return this.stop(message ? `\u274C ${message}` : `\u274C ${this.message}`);
-  }
-}
-export function createSpinner(message) {
-  return new SimpleSpinner(message);
-}

package/bin/libs/sdk/sdk-impl/utils/utils-build.d.ts

@@ -1,33 +0,0 @@
-import type { DlerConfig, NpmOutExt, Sourcemap } from "../config/types.js";
-/**
- * Converts the Unified build sourcemap option to a Bun-friendly value.
- * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
- * @returns "none", "inline", or "external" for Bun's bundler.
- */
-export declare function getBunSourcemapOption(transpileSourcemap: Sourcemap): "external" | "inline" | "none";
-/**
- * Converts the Unified build sourcemap option to a Rollup/Unified-bundler friendly value.
- * @param transpileSourcemap - The sourcemap configuration ('none', 'inline', 'linked', 'external', true, false).
- * @returns "inline" if inline is specified; true for linked/external or boolean true; otherwise false.
- */
-export declare function getUnifiedSourcemapOption(transpileSourcemap: Sourcemap): "inline" | boolean;
-/**
- * Renames the primary output file (and its declaration file, if applicable)
- * in the output directory.
- *
- * @deprecated Earlier dler used to rename to a standardized name (e.g., mod.js, mod.ts).
- *
- * TODO: It will be removed in the future.
- *
- * @param isJsr - Flag indicating if the target platform is JSR.
- * @param outDirBin - The output directory where the compiled files reside.
- * @param originalEntryFileBasename - The base name (file name only) of the original entry file processed by the bundler.
- * @param unifiedBundlerOutExt - The file extension used for standard (non-JSR) builds (e.g., 'js', 'mjs').
- * @param distJsrOutFilesExt - The file extension used for JSR builds (likely 'ts' or 'js').
- * @param config - The configuration object.
- * @returns An object containing the new base name of the entry file.
- * @throws If the expected source entry file is not found in the output directory.
- */
-export declare function renameEntryFile(isJsr: boolean, outDirBin: string, originalEntryFileBasename: string, unifiedBundlerOutExt: NpmOutExt, distJsrOutFilesExt: NpmOutExt, config: DlerConfig): Promise<{
-    updatedEntryFile: string;
-}>;

package/bin/libs/sdk/sdk-impl/utils/utils-clean.d.ts

@@ -1,11 +0,0 @@
-import type { LibConfig } from "../config/types.js";
-/**
- * Recursively removes any existing distribution folders.
- */
-export declare function removeDistFolders(distNpmDirName: string, distJsrDirName: string, libsDirDist: string, libsList: Record<string, LibConfig>, distTmpDirName?: string): Promise<boolean>;
-/**
- * Removes logInternal and relinka "internal" calls from TypeScript/JavaScript files
- * @param targetDir Directory to process recursively
- * @returns Promise<boolean> True if successful
- */
-export declare function removeLogInternalCalls(targetDir: string): Promise<boolean>;

package/bin/libs/sdk/sdk-impl/utils/utils-clean.js

@@ -1,70 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { CONCURRENCY_DEFAULT, PROJECT_ROOT } from "./utils-consts.js";
-export async function removeDistFolders(distNpmDirName, distJsrDirName, libsDirDist, libsList, distTmpDirName = "") {
-  const foldersToRemove = [];
-  foldersToRemove.push(distNpmDirName);
-  foldersToRemove.push(distJsrDirName);
-  if (distTmpDirName !== "") {
-    foldersToRemove.push(distTmpDirName);
-  }
-  if (libsList && Object.keys(libsList).length > 0) {
-    foldersToRemove.push(libsDirDist);
-  }
-  const existingFolders = [];
-  for (const folder of foldersToRemove) {
-    const folderPath = path.resolve(PROJECT_ROOT, folder);
-    if (await fs.pathExists(folderPath)) {
-      existingFolders.push(folder);
-    }
-  }
-  if (existingFolders.length > 0) {
-    await pMap(
-      existingFolders,
-      async (folder) => {
-        const folderPath = path.resolve(PROJECT_ROOT, folder);
-        if (await fs.pathExists(folderPath)) {
-          await fs.remove(folderPath);
-          relinka("verbose", `Removed: ${folderPath}`);
-        }
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-    );
-    relinka("verbose", "Distribution folders removed successfully");
-  }
-  return true;
-}
-export async function removeLogInternalCalls(targetDir) {
-  const files = await fs.readdir(targetDir, { recursive: true });
-  const tsJsFiles = files.filter(
-    (file) => file.endsWith(".ts") || file.endsWith(".js") || file.endsWith(".tsx") || file.endsWith(".jsx")
-  );
-  await pMap(
-    tsJsFiles,
-    async (file) => {
-      const filePath = path.join(targetDir, file);
-      const content = await fs.readFile(filePath, "utf8");
-      let newContent = content.replace(
-        /logInternal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(
-        /relinka\s*\(\s*["']internal["']\s*,\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(
-        /relinka\.internal\s*\(\s*(?:`[^`]*`|'[^']*'|"[^"]*"|(?:[^;]*?,\s*)*[^;]*?)\s*\)\s*;?/g,
-        ""
-      );
-      newContent = newContent.replace(/\n\s*\n\s*\n/g, "\n\n").replace(/^\s*\n/gm, "").replace(/\n\s*$/g, "\n");
-      if (newContent !== content) {
-        await fs.writeFile(filePath, newContent);
-      }
-    },
-    { concurrency: CONCURRENCY_DEFAULT }
-  );
-  relinka("verbose", "Successfully removed logInternal and relinka internal calls from files");
-  return true;
-}

package/bin/libs/sdk/sdk-impl/utils/utils-consts.d.ts

@@ -1,9 +0,0 @@
-export declare const PROJECT_ROOT: string;
-export declare const CONCURRENCY_DEFAULT = 1;
-export declare const tsconfigJson = "tsconfig.json";
-export declare const cliDomainDocs = "https://docs.reliverse.org";
-export declare const validExtensions: string[];
-export declare const SHOW_VERBOSE: {
-    getDirectorySize: boolean;
-    readFileSafe: boolean;
-};

package/bin/libs/sdk/sdk-impl/utils/utils-consts.js

@@ -1,10 +0,0 @@
-import path from "@reliverse/pathkit";
-export const PROJECT_ROOT = path.resolve(process.cwd());
-export const CONCURRENCY_DEFAULT = 1;
-export const tsconfigJson = "tsconfig.json";
-export const cliDomainDocs = "https://docs.reliverse.org";
-export const validExtensions = ["cjs", "js", "mjs", "ts", "mts", "cts"];
-export const SHOW_VERBOSE = {
-  getDirectorySize: false,
-  readFileSafe: false
-};

package/bin/libs/sdk/sdk-impl/utils/utils-deps.d.ts

@@ -1,5 +0,0 @@
-import type { DlerConfig } from "../config/types.js";
-/**
- * Filters out development dependencies from a dependency record.
- */
-export declare function filterDeps(deps: Record<string, string> | undefined, clearUnused: boolean, outDirBin: string, isJsr: boolean, config: DlerConfig, libName?: string): Promise<Record<string, string>>;

package/bin/libs/sdk/sdk-impl/utils/utils-determine.d.ts

@@ -1,12 +0,0 @@
-import type { LibConfig } from "../config/types.js";
-/**
- * Determines the distribution name based on the file path and build type.
- * This function is used for logging and determining output paths.
- *
- * @returns The distribution name in the transpileFormat of:
- *   - For empty isJsr: "root"
- *   - For regular builds: "dist-jsr" or "dist-npm"
- *   - For library builds: "dist-libs/{lib-name}/jsr" or "dist-libs/{lib-name}/npm"
- *   - For library builds with libDirName: "dist-libs/{libDirName}/jsr" or "dist-libs/{libDirName}/npm"
- */
-export declare function determineDistName(filePath: string, isJsr: "" | boolean, libsList?: Record<string, LibConfig>): string;

package/bin/libs/sdk/sdk-impl/utils/utils-fs.js

@@ -1,183 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { glob } from "tinyglobby";
-import { CONCURRENCY_DEFAULT, SHOW_VERBOSE } from "./utils-consts.js";
-import { determineDistName } from "./utils-determine.js";
-export async function copyRootFile(outDirRoot, fileNames) {
-  if (fileNames.length === 0) {
-    return;
-  }
-  const EXCLUDED_FILES = ["bin", "jsr.json", "jsr.jsonc", "package.json"];
-  try {
-    await fs.ensureDir(outDirRoot);
-    const specialFileHandlers = {
-      LICENSE: {
-        variants: ["LICENSE", "LICENSE.md", "LICENSES"]
-      },
-      README: {
-        variants: ["README.md", "README"]
-      }
-    };
-    await pMap(
-      fileNames,
-      async (fileName) => {
-        try {
-          if (EXCLUDED_FILES.includes(fileName)) {
-            relinka(
-              "verbose",
-              `The following artifact is auto-generated in dist and will not be copied from the root: ${fileName}`
-            );
-            return;
-          }
-          const specialConfig = specialFileHandlers[fileName];
-          if (specialConfig?.variants) {
-            for (const variant of specialConfig.variants) {
-              const file = await findFileCaseInsensitive(variant);
-              if (file) {
-                const targetPath = path.join(outDirRoot, variant);
-                if (await fs.pathExists(targetPath)) {
-                  await fs.remove(targetPath);
-                }
-                await fs.copy(file, targetPath, { errorOnExist: true });
-                relinka("verbose", `Copied ${file} to ${outDirRoot}/${variant}`);
-              }
-            }
-          } else {
-            const file = await findFileCaseInsensitive(fileName);
-            if (file) {
-              const targetPath = path.join(outDirRoot, fileName);
-              if (await fs.pathExists(targetPath)) {
-                await fs.remove(targetPath);
-              }
-              await fs.copy(file, targetPath, { errorOnExist: true });
-              relinka("verbose", `Copied ${file} to ${outDirRoot}/${fileName}`);
-            }
-          }
-        } catch (fileError) {
-          relinka("error", `Failed to copy ${fileName}: ${fileError}`);
-        }
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-      // Process up to CONCURRENCY_DEFAULT files simultaneously
-    );
-  } catch (error) {
-    relinka("error", `Failed to copy files: ${error}`);
-    throw new Error(`File copying failed: ${error}`);
-  }
-}
-export async function getDirectorySize(outDirRoot, isDev) {
-  if (SHOW_VERBOSE.getDirectorySize) {
-    relinka("verbose", `Calculating directory size for: ${outDirRoot}`);
-  }
-  try {
-    const files = await fs.readdir(outDirRoot);
-    const sizes = await pMap(
-      files,
-      async (file) => {
-        const fp = path.join(outDirRoot, file);
-        const stats = await fs.stat(fp);
-        return stats.isDirectory() ? getDirectorySize(fp, isDev) : stats.size;
-      },
-      { concurrency: CONCURRENCY_DEFAULT }
-    );
-    const totalSize = sizes.reduce((total, s) => total + s, 0);
-    if (SHOW_VERBOSE.getDirectorySize) {
-      relinka("verbose", `Calculated directory size: ${totalSize} bytes for ${outDirRoot}`);
-    }
-    return totalSize;
-  } catch (error) {
-    relinka("error", `Failed to calculate directory size for ${outDirRoot}`, error);
-    return 0;
-  }
-}
-export async function outDirBinFilesCount(outDirBin) {
-  relinka("verbose", `Counting files in directory: ${outDirBin}`);
-  let fileCount = 0;
-  if (!await fs.pathExists(outDirBin)) {
-    relinka("error", `[outDirBinFilesCount] Directory does not exist: ${outDirBin}`);
-    return fileCount;
-  }
-  await fs.dive(outDirBin, () => {
-    fileCount++;
-  });
-  relinka("verbose", `Total file count in ${outDirBin}: ${fileCount}`);
-  return fileCount;
-}
-async function findFileCaseInsensitive(transpileTargetFile) {
-  const files = await fs.readdir(".");
-  const found = files.find((file) => file.toLowerCase() === transpileTargetFile.toLowerCase());
-  return found || null;
-}
-const TEST_FILE_PATTERNS = [
-  "**/*.test.js",
-  "**/*.test.ts",
-  "**/*.test.d.ts",
-  "**/*-temp.js",
-  "**/*-temp.ts",
-  "**/*-temp.d.ts",
-  "**/__snapshots__/**"
-];
-export async function deleteSpecificFiles(outDirBin) {
-  relinka("verbose", `Deleting test and temporary files in: ${outDirBin}`);
-  const files = await glob(TEST_FILE_PATTERNS, {
-    absolute: true,
-    cwd: outDirBin
-  });
-  const snapshotDirs = await glob("**/__snapshots__", {
-    absolute: true,
-    cwd: outDirBin,
-    onlyDirectories: true
-  });
-  const filesToDelete = files.filter((file) => {
-    if (file.endsWith(".d.ts")) {
-      return file.includes(".test.d.ts") || file.includes("-temp.d.ts");
-    }
-    return true;
-  });
-  if (filesToDelete.length > 0) {
-    await pMap(filesToDelete, async (file) => fs.remove(file), {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", `Deleted files:
-${filesToDelete.join("\n")}`);
-  }
-  if (snapshotDirs.length > 0) {
-    await pMap(snapshotDirs, async (dir) => fs.remove(dir), {
-      concurrency: CONCURRENCY_DEFAULT
-    });
-    relinka("verbose", `Deleted snapshot directories:
-${snapshotDirs.join("\n")}`);
-  }
-}
-export async function readFileSafe(filePath, isJsr, reason) {
-  const distName = determineDistName(filePath, isJsr, void 0);
-  try {
-    const content = await fs.readFile(filePath, "utf8");
-    if (SHOW_VERBOSE.readFileSafe) {
-      relinka("verbose", `[${distName}] Successfully read file: ${filePath} [Reason: ${reason}]`);
-    }
-    return content;
-  } catch (error) {
-    relinka("error", `[${distName}] Failed to read file: ${filePath} [Reason: ${reason}]`, error);
-    throw error;
-  }
-}
-export async function writeFileSafe(filePath, content, reason) {
-  try {
-    await fs.writeFile(filePath, content, "utf8");
-    relinka("verbose", `Successfully wrote file: ${filePath} [Reason: ${reason}]`);
-  } catch (error) {
-    relinka("error", `Failed to write file: ${filePath} [Reason: ${reason}]`, error);
-    throw error;
-  }
-}
-export async function validateDirectory(dir) {
-  try {
-    const stat = await fs.stat(dir);
-    return stat.isDirectory();
-  } catch {
-    return false;
-  }
-}

package/bin/libs/sdk/sdk-impl/utils/utils-jsr-json.d.ts

@@ -1,9 +0,0 @@
-import type { DlerConfig, LibConfig } from "../config/types.js";
-/**
- * Generates a jsr.json configuration file for JSR distributions.
- */
-export declare function createJsrJSON(outDirRoot: string, isLib: boolean, libsList: Record<string, LibConfig>, config: DlerConfig, libName?: string, pkgDescription?: string): Promise<void>;
-/**
- * Renames .tsx files by replacing the .tsx extension with -tsx.txt.
- */
-export declare function renameTsxFiles(dir: string): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/utils-jsr-json.js

@@ -1,75 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import pMap from "p-map";
-import { readPackageJSON } from "pkg-types";
-import { glob } from "tinyglobby";
-import { cliDomainDocs, CONCURRENCY_DEFAULT } from "./utils-consts.js";
-export async function createJsrJSON(outDirRoot, isLib, libsList, config, libName = "unknown-lib-name", pkgDescription = "unknown-lib-description") {
-  relinka("verbose", `Creating jsr.json configuration (isLib: ${isLib})`);
-  const originalPkg = await readPackageJSON();
-  let { description, name } = originalPkg;
-  const { author, license, version } = originalPkg;
-  if (isLib) {
-    name = libName;
-    description = pkgDescription;
-    if (!libsList[libName]?.libMainFile) {
-      throw new Error(`libsList.${libName}.libMainFile is not defined for library ${libName}`);
-    }
-  }
-  const pkgHomepage = cliDomainDocs;
-  const jsrConfig = {
-    author,
-    description,
-    exports: isLib && libsList[libName]?.libMainFile ? `./bin/${path.basename(libsList[libName].libMainFile)}` : `./bin/${config.coreEntryFile}`,
-    homepage: pkgHomepage,
-    license: license || "MIT",
-    name,
-    publish: {
-      exclude: ["!.", "node_modules/**", ".env"]
-    },
-    version
-  };
-  const jsrArtifacts = isLib ? config.publishArtifacts?.["dist-libs"]?.[libName]?.jsr : config.publishArtifacts?.["dist-jsr"] || ["jsr.json"];
-  const jsrConfigExt = jsrArtifacts?.find((artifact) => artifact.startsWith("jsr.json"))?.split(".").pop() || "json";
-  const jsrConfigPath = path.join(outDirRoot, `jsr.${jsrConfigExt}`);
-  await fs.writeJSON(jsrConfigPath, jsrConfig, {
-    spaces: 2
-  });
-  relinka("verbose", `Generated jsr.${jsrConfigExt} file in ${outDirRoot}/jsr.${jsrConfigExt}`);
-}
-export async function renameTsxFiles(dir) {
-  relinka("verbose", `Renaming .tsx files in directory: ${dir}`);
-  const files = await glob(["**/*.tsx"], {
-    absolute: true,
-    cwd: dir
-  });
-  const processedPaths = /* @__PURE__ */ new Set();
-  await pMap(
-    files,
-    async (filePath) => {
-      const newPath = filePath.replace(/\.tsx$/, "-tsx.txt");
-      if (processedPaths.has(newPath)) {
-        throw new Error(`Path conflict detected: ${newPath} would be created multiple times`);
-      }
-      if (await fs.pathExists(newPath)) {
-        throw new Error(`Target file already exists: ${newPath}`);
-      }
-      try {
-        await fs.rename(filePath, newPath);
-        processedPaths.add(newPath);
-        relinka("verbose", `Renamed: ${filePath} -> ${newPath}`);
-        if (await fs.pathExists(filePath)) {
-          throw new Error(`Source file still exists after rename: ${filePath}`);
-        }
-        if (!await fs.pathExists(newPath)) {
-          throw new Error(`Target file not found after rename: ${newPath}`);
-        }
-      } catch (error) {
-        throw new Error(`Failed to rename ${filePath} to ${newPath}: ${error}`);
-      }
-    },
-    { concurrency: CONCURRENCY_DEFAULT }
-  );
-  relinka("verbose", `Completed renaming .tsx files in ${dir}`);
-}

package/bin/libs/sdk/sdk-impl/utils/utils-package-json-libraries.d.ts

@@ -1,10 +0,0 @@
-import type { NpmOutExt, DlerConfig, LibConfig } from "../config/types.js";
-/**
- * Creates a package.json for a lib distribution.
- */
-export declare function library_createPackageJSON(libName: string, npmOutDir: string, jsrOutDir: string, effectivePubRegistry: "npm" | "jsr" | "npm-jsr" | undefined, libsList: Record<string, LibConfig>, config: DlerConfig, unifiedBundlerOutExt: NpmOutExt): Promise<void>;
-/**
- * Creates a JSR configuration file for a library.
- */
-declare function library_createJsrConfig(libName: string, pkgJsonDir: string, libsList: Record<string, LibConfig>, config: DlerConfig): Promise<void>;
-export { library_createJsrConfig };

package/bin/libs/sdk/sdk-impl/utils/utils-package-json-regular.d.ts

@@ -1,8 +0,0 @@
-import type { DlerConfig, NpmOutExt } from "../config/types.js";
-/**
- * Creates a package.json for the main distribution.
- */
-export declare function regular_createPackageJSON(outDirRoot: string, isJsr: boolean, coreIsCLI: {
-    enabled: boolean;
-    scripts: Record<string, string>;
-}, unifiedBundlerOutExt: NpmOutExt, config: DlerConfig, coreDescription: string, coreBuildOutDir?: string): Promise<void>;

package/bin/libs/sdk/sdk-impl/utils/utils-package-json-regular.js

@@ -1,165 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-import { relinka } from "@reliverse/relinka";
-import { definePackageJSON, readPackageJSON } from "pkg-types";
-import { cliDomainDocs } from "./utils-consts.js";
-import { filterDeps } from "./utils-deps.js";
-export async function regular_createPackageJSON(outDirRoot, isJsr, coreIsCLI, unifiedBundlerOutExt, config, coreDescription, coreBuildOutDir = "bin") {
-  relinka("verbose", `Generating distribution package.json and tsconfig.json (isJsr=${isJsr})...`);
-  const commonPkg = await regular_createCommonPackageFields(coreIsCLI, coreDescription);
-  const originalPkg = await readPackageJSON();
-  const packageName = originalPkg.name || "";
-  relinka(
-    "verbose",
-    `Package name: "${packageName}", CLI enabled: ${coreIsCLI.enabled}, scripts: ${JSON.stringify(coreIsCLI.scripts)}`
-  );
-  const outDirBin = path.join(outDirRoot, coreBuildOutDir);
-  const outExt = unifiedBundlerOutExt || "js";
-  if (isJsr) {
-    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
-      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
-        name,
-        `${coreBuildOutDir}/${path.basename(script)}`
-      ])
-    ) : void 0;
-    if (coreIsCLI.enabled) {
-      relinka("verbose", `Adding CLI bin entries for JSR: ${JSON.stringify(binEntry)}`);
-    }
-    const jsrPkg = definePackageJSON({
-      ...commonPkg,
-      bin: binEntry,
-      dependencies: await regular_getPkgKeepDeps(originalPkg.dependencies, outDirBin, true, config),
-      devDependencies: await filterDeps(originalPkg.devDependencies, true, outDirBin, true, config),
-      exports: {
-        ".": `./${coreBuildOutDir}/${config.coreEntryFile}`
-      },
-      files: [
-        .../* @__PURE__ */ new Set([
-          coreBuildOutDir,
-          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-        ])
-      ]
-    });
-    await fs.writeJSON(path.join(outDirRoot, "package.json"), jsrPkg, {
-      spaces: 2
-    });
-    if (coreIsCLI.enabled) {
-      relinka(
-        "verbose",
-        `JSR package.json created with CLI bin entries: ${JSON.stringify(jsrPkg.bin)}`
-      );
-    }
-  } else {
-    const binEntry = coreIsCLI.enabled ? Object.fromEntries(
-      Object.entries(coreIsCLI.scripts).map(([name, script]) => [
-        name,
-        `${coreBuildOutDir}/${path.basename(script).replace(/\.ts$/, `.${outExt}`)}`
-      ])
-    ) : void 0;
-    if (coreIsCLI.enabled) {
-      relinka("verbose", `Adding CLI bin entries for NPM: ${JSON.stringify(binEntry)}`);
-    }
-    const npmPkg = definePackageJSON({
-      ...commonPkg,
-      bin: binEntry,
-      dependencies: await regular_getPkgKeepDeps(
-        originalPkg.dependencies,
-        outDirBin,
-        false,
-        config
-      ),
-      devDependencies: await filterDeps(
-        originalPkg.devDependencies,
-        true,
-        outDirBin,
-        false,
-        config
-      ),
-      exports: {
-        ".": `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`
-      },
-      files: [
-        .../* @__PURE__ */ new Set([
-          coreBuildOutDir,
-          ...config.publishArtifacts?.global || ["package.json", "README.md", "LICENSE"]
-        ])
-      ],
-      main: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
-      module: `./${coreBuildOutDir}/${config.coreEntryFile.replace(/\.ts$/, `.${outExt}`)}`,
-      publishConfig: { access: "public" }
-    });
-    await fs.writeJSON(path.join(outDirRoot, "package.json"), npmPkg, {
-      spaces: 2
-    });
-    if (coreIsCLI.enabled) {
-      relinka(
-        "verbose",
-        `NPM package.json created with CLI bin entries: ${JSON.stringify(npmPkg.bin)}`
-      );
-    }
-  }
-  relinka("verbose", `Created package.json in ${outDirRoot}`);
-}
-async function regular_createCommonPackageFields(coreIsCLI, coreDescription) {
-  relinka("verbose", "Generating common package fields");
-  const originalPkg = await readPackageJSON();
-  const { author, description, keywords, license, name, version } = originalPkg;
-  relinka("verbose", `Original package name: "${name}", version: "${version}"`);
-  const pkgHomepage = cliDomainDocs;
-  const commonPkg = {
-    dependencies: originalPkg.dependencies || {},
-    description: coreDescription || description,
-    homepage: pkgHomepage,
-    license: license || "MIT",
-    name,
-    type: "module",
-    version
-  };
-  if (coreIsCLI.enabled) {
-    relinka("verbose", "coreIsCLI is enabled, adding CLI-specific fields to common package fields");
-    if (commonPkg.keywords) {
-      const cliKeywords = Object.keys(coreIsCLI.scripts);
-      relinka(
-        "verbose",
-        `Adding CLI keywords to existing keywords: ${JSON.stringify(cliKeywords)}`
-      );
-      commonPkg.keywords = [
-        .../* @__PURE__ */ new Set(["cli", ...cliKeywords, "command-line", ...commonPkg.keywords])
-      ];
-      relinka("verbose", `Updated keywords: ${JSON.stringify(commonPkg.keywords)}`);
-    } else if (name) {
-      const cliKeywords = Object.keys(coreIsCLI.scripts);
-      relinka("verbose", `Setting new CLI keywords: ${JSON.stringify(cliKeywords)}`);
-      commonPkg.keywords = ["cli", "command-line", ...cliKeywords];
-      relinka("verbose", `Set keywords: ${JSON.stringify(commonPkg.keywords)}`);
-    }
-  } else {
-    relinka("verbose", "coreIsCLI is false, skipping CLI-specific fields");
-  }
-  if (author) {
-    const repoOwner = typeof author === "string" ? author : author.name;
-    const repoName = name ? name.startsWith("@") ? name.split("/").pop() || name : name : "";
-    Object.assign(commonPkg, {
-      author,
-      bugs: {
-        email: "blefnk@gmail.com",
-        url: `https://github.com/${repoOwner}/${repoName}/issues`
-      },
-      keywords: [.../* @__PURE__ */ new Set([repoOwner, ...commonPkg.keywords || []])],
-      repository: {
-        type: "git",
-        url: `git+https://github.com/${repoOwner}/${repoName}.git`
-      }
-    });
-  } else if (keywords && keywords.length > 0 && !commonPkg.keywords) {
-    commonPkg.keywords = keywords;
-  }
-  relinka("verbose", "Common package fields generated");
-  return commonPkg;
-}
-async function regular_getPkgKeepDeps(originalDeps, outDirBin, isJsr, config) {
-  if (!originalDeps) {
-    return {};
-  }
-  return filterDeps(originalDeps, false, outDirBin, isJsr, config);
-}

package/bin/libs/sdk/sdk-impl/utils/utils-perf.d.ts

@@ -1,5 +0,0 @@
-import type { PerfTimer } from "../sdk-types.js";
-export declare function createPerfTimer(): PerfTimer;
-export declare function getElapsedPerfTime(timer: PerfTimer): number;
-export declare function pausePerfTimer(timer: PerfTimer): void;
-export declare function resumePerfTimer(timer: PerfTimer): void;