@reliverse/dler 1.7.92 → 1.7.93

package/bin/app/utils/native-cli/nc-impl.js

@@ -0,0 +1,154 @@
+import { dirname, join } from "@reliverse/pathkit";
+import fs, { ensuredir } from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { installDependencies } from "nypm";
+import { ofetch } from "ofetch";
+import pLimit from "p-limit";
+import semver from "semver";
+import { glob } from "tinyglobby";
+import { fileURLToPath } from "url";
+const verbose = false;
+const BASE_URL = "https://jsr.io";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function fetchJson(url) {
+  try {
+    return await ofetch(url, {
+      headers: { Accept: "application/json" }
+    });
+  } catch (error) {
+    throw new Error(`Failed to fetch JSON from "${url}" (error: ${error})`);
+  }
+}
+async function getPackageMeta(scope, packageName) {
+  const url = `${BASE_URL}/@${scope}/${packageName}/meta.json`;
+  return fetchJson(url);
+}
+function pickVersionFromMeta(meta, userVersion) {
+  if (userVersion) {
+    const info = meta.versions[userVersion];
+    if (!info) {
+      throw new Error(`Version "${userVersion}" not found in package metadata.`);
+    }
+    if (info.yanked) {
+      throw new Error(`Version "${userVersion}" is yanked and cannot be downloaded.`);
+    }
+    return userVersion;
+  }
+  const versions = Object.keys(meta.versions).filter((v) => {
+    const versionInfo = meta.versions[v];
+    return versionInfo && !versionInfo.yanked && semver.valid(v);
+  });
+  if (versions.length === 0) {
+    throw new Error("No valid (non-yanked, semver) versions found for this package.");
+  }
+  versions.sort((a, b) => semver.rcompare(a, b));
+  return versions[0];
+}
+async function getVersionMeta(scope, packageName, version) {
+  const url = `${BASE_URL}/@${scope}/${packageName}/${version}_meta.json`;
+  return fetchJson(url);
+}
+async function downloadFile(scope, packageName, version, filePath, outputDir, useSinglePath) {
+  const trimmedFilePath = filePath.replace(/^\//, "");
+  const url = `${BASE_URL}/@${scope}/${packageName}/${version}/${trimmedFilePath}`;
+  const buffer = Buffer.from(
+    await ofetch(url, {
+      headers: { Accept: "*/*" },
+      responseType: "arrayBuffer"
+    })
+  );
+  const targetFilePath = useSinglePath ? join(outputDir, trimmedFilePath) : join(outputDir, scope, packageName, version, trimmedFilePath);
+  await ensuredir(dirname(targetFilePath));
+  await fs.writeFile(targetFilePath, buffer);
+  relinka("verbose", `Downloaded: ${url} -> ${targetFilePath}`);
+}
+async function isPackageDownloaded(filePaths, outputDir, useSinglePath, scope, packageName, version) {
+  try {
+    for (const filePath of filePaths) {
+      const trimmedFilePath = filePath.replace(/^\//, "");
+      const targetFilePath = useSinglePath ? join(outputDir, trimmedFilePath) : join(outputDir, scope, packageName, version, trimmedFilePath);
+      if (!await fs.pathExists(targetFilePath)) {
+        return false;
+      }
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function renameTxtToTsx(dir) {
+  try {
+    const files = await glob("**/*-tsx.txt", {
+      cwd: dir,
+      absolute: true
+    });
+    for (const filePath of files) {
+      const newPath = filePath.replace(/-tsx\.txt$/, ".tsx");
+      await fs.rename(filePath, newPath);
+      if (verbose) {
+        relinka("verbose", `Renamed: ${filePath} -> ${newPath}`);
+      }
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "Error renaming -tsx.txt files:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+export async function downloadJsrDist(scope, packageName, version, outputDir = join(__dirname, "output"), useSinglePath = true, concurrency = 5, pkgIsCLI = true, msgDownloadStarted, revertTsxFiles = false, cliInstallDeps = true) {
+  try {
+    const meta = await getPackageMeta(scope, packageName);
+    const resolvedVersion = version || pickVersionFromMeta(meta);
+    const versionMeta = await getVersionMeta(scope, packageName, resolvedVersion);
+    const filePaths = Object.keys(versionMeta.manifest);
+    const isDownloaded = await isPackageDownloaded(
+      filePaths,
+      outputDir,
+      useSinglePath,
+      scope,
+      packageName,
+      resolvedVersion
+    );
+    if (isDownloaded) {
+      relinka(
+        "success",
+        `@${scope}/${packageName}@${resolvedVersion} is already downloaded.`,
+        pkgIsCLI ? `Use "bun ${outputDir}/bin/mod.ts" to run it (short command coming soon).` : void 0
+      );
+      return;
+    }
+    relinka(
+      "info",
+      msgDownloadStarted ?? `Downloading ${scope}/${packageName}@${resolvedVersion} from JSR...`
+    );
+    const limit = pLimit(concurrency);
+    const tasks = filePaths.map(
+      (filePath) => limit(
+        () => downloadFile(scope, packageName, resolvedVersion, filePath, outputDir, useSinglePath)
+      )
+    );
+    await Promise.all(tasks);
+    if (pkgIsCLI && revertTsxFiles) {
+      relinka("verbose", "Reverting .tsx files...");
+      await renameTxtToTsx(outputDir);
+    }
+    if (pkgIsCLI && cliInstallDeps) {
+      relinka("info", "Installing dependencies...");
+      await installDependencies({
+        cwd: outputDir,
+        silent: false
+      });
+    }
+    relinka(
+      "success",
+      `All files for @${scope}/${packageName} downloaded successfully.`,
+      pkgIsCLI ? `Use "bun ${outputDir}/bin/mod.ts" to run it (short command coming soon).` : void 0
+    );
+  } catch (error) {
+    relinka("error", `Something went wrong while downloading ${scope}/${packageName}:`, `${error}`);
+    throw error;
+  }
+}

package/bin/app/utils/native-cli/nc-mod.d.ts

@@ -0,0 +1,3 @@
+export declare function showNativeCliMenu({ outputDir }: {
+    outputDir: string;
+}): Promise<void>;

package/bin/app/utils/native-cli/nc-mod.js

@@ -0,0 +1,44 @@
+import fs from "@reliverse/relifso";
+import { confirmPrompt } from "@reliverse/rempts";
+import { downloadJsrDist } from "./nc-impl.js";
+export async function showNativeCliMenu({ outputDir }) {
+  const dirExists = await fs.pathExists(outputDir);
+  if (dirExists) {
+    try {
+      const files = await fs.readdir(outputDir);
+      if (files.length > 0) {
+        const shouldOverwrite = await confirmPrompt({
+          title: "Bun runtime files already exist in the target directory.",
+          content: "Do you want to proceed and potentially overwrite existing files?",
+          defaultValue: false
+        });
+        if (!shouldOverwrite) {
+          return;
+        }
+      }
+    } catch (error) {
+      console.error("Error checking directory:", error);
+    }
+  }
+  const shouldUseBunRuntime = await confirmPrompt({
+    title: "I see you have Bun installed, but the process was run using the Node.js runtime. Do you want to use the Bun runtime?",
+    content: "Press <Enter> to allow me to download the CLI from JSR and install it globally. (The download speed depends on your internet connection.)",
+    defaultValue: true
+  });
+  if (!shouldUseBunRuntime) {
+    return;
+  }
+  await downloadJsrDist(
+    "rse",
+    "cli",
+    void 0,
+    // This will pick the latest version automatically
+    outputDir,
+    true,
+    5,
+    true,
+    "Downloading Bun-native rse from JSR...",
+    true,
+    true
+  );
+}

package/bin/app/utils/pkgJsonHelpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Checks if a specific script exists in package.json
+ * @param projectPath - Path to the project directory containing package.json
+ * @param scriptName - Name of the script to check for
+ * @returns Promise resolving to true if the script exists, false otherwise
+ */
+export declare function checkScriptExists(projectPath: string, scriptName: string): Promise<boolean>;

package/bin/app/utils/pkgJsonHelpers.js

@@ -0,0 +1,15 @@
+import { relinka } from "@reliverse/relinka";
+import { readPackageJSON } from "pkg-types";
+export async function checkScriptExists(projectPath, scriptName) {
+  try {
+    const packageJson = await readPackageJSON(projectPath);
+    return !!packageJson?.scripts?.[scriptName];
+  } catch (error) {
+    relinka(
+      "error",
+      `Error checking for script ${scriptName}:`,
+      error instanceof Error ? error.message : String(error)
+    );
+    return false;
+  }
+}

package/bin/app/utils/pm/pm-api.js

@@ -0,0 +1,170 @@
+import { resolve } from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { readPackageJSON } from "pkg-types";
+import {
+  doesDependencyExist,
+  executeCommand,
+  getWorkspaceArgs,
+  resolveOperationOptions
+} from "./pm-utils.js";
+export async function installDependencies(options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const pmToFrozenLockfileInstallCommand = {
+    npm: ["ci"],
+    yarn: ["install", "--immutable"],
+    bun: ["install", "--frozen-lockfile"],
+    pnpm: ["install", "--frozen-lockfile"],
+    deno: ["install", "--frozen"]
+  };
+  const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
+  const workspaceArgs = getWorkspaceArgs(resolvedOptions);
+  const finalArgs = [...commandArgs, ...workspaceArgs];
+  await executeCommand(resolvedOptions.packageManager.command, finalArgs, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}
+export async function addDependency(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const names = Array.isArray(name) ? name : [name];
+  if (resolvedOptions.packageManager.name === "deno") {
+    for (let i = 0; i < names.length; i++) {
+      if (!/^(npm|jsr|file):.+$/.test(names[i] || "")) {
+        names[i] = `npm:${names[i]}`;
+      }
+    }
+  }
+  if (names.length === 0) {
+    return;
+  }
+  const args = (resolvedOptions.packageManager.name === "yarn" ? [
+    ...getWorkspaceArgs(resolvedOptions),
+    // Global is not supported in berry: yarnpkg/berry#821
+    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
+    "add",
+    resolvedOptions.dev ? "-D" : "",
+    ...names
+  ] : [
+    resolvedOptions.packageManager.name === "npm" ? "install" : "add",
+    ...getWorkspaceArgs(resolvedOptions),
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    ...names
+  ]).filter(Boolean);
+  await executeCommand(resolvedOptions.packageManager.command, args, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+  if (options.installPeerDependencies) {
+    const existingPkg = await readPackageJSON(resolvedOptions.cwd);
+    const peerDeps = [];
+    const peerDevDeps = [];
+    for (const _name of names) {
+      const pkgName = _name.match(/^(.[^@]+)/)?.[0];
+      const pkg = await readPackageJSON(pkgName, {
+        url: resolvedOptions.cwd
+      }).catch(() => ({}));
+      if (!pkg.peerDependencies || pkg.name !== pkgName) {
+        continue;
+      }
+      for (const [peerDependency, version] of Object.entries(pkg.peerDependencies)) {
+        if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) {
+          continue;
+        }
+        if (existingPkg.dependencies?.[peerDependency] || existingPkg.devDependencies?.[peerDependency]) {
+          continue;
+        }
+        const isDev = pkg.peerDependenciesMeta?.[peerDependency]?.dev;
+        (isDev ? peerDevDeps : peerDeps).push(`${peerDependency}@${version}`);
+      }
+    }
+    if (peerDeps.length > 0) {
+      await addDependency(peerDeps, { ...resolvedOptions });
+    }
+    if (peerDevDeps.length > 0) {
+      await addDevDependency(peerDevDeps, { ...resolvedOptions });
+    }
+  }
+}
+export async function addDevDependency(name, options = {}) {
+  await addDependency(name, { ...options, dev: true });
+}
+export async function removeDependency(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const names = Array.isArray(name) ? name : [name];
+  if (names.length === 0) {
+    return;
+  }
+  const args = (resolvedOptions.packageManager.name === "yarn" ? [
+    // Global is not supported in berry: yarnpkg/berry#821
+    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
+    ...getWorkspaceArgs(resolvedOptions),
+    "remove",
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    ...names
+  ] : [
+    resolvedOptions.packageManager.name === "npm" ? "uninstall" : "remove",
+    ...getWorkspaceArgs(resolvedOptions),
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    ...names
+  ]).filter(Boolean);
+  await executeCommand(resolvedOptions.packageManager.command, args, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}
+export async function ensureDependencyInstalled(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const dependencyExists = doesDependencyExist(name, resolvedOptions);
+  if (dependencyExists) {
+    return true;
+  }
+  await addDependency(name, resolvedOptions);
+}
+export async function dedupeDependencies(options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const isSupported = !["bun", "deno"].includes(resolvedOptions.packageManager.name);
+  const recreateLockfile = options.recreateLockfile ?? !isSupported;
+  if (recreateLockfile) {
+    const lockfiles = Array.isArray(resolvedOptions.packageManager.lockFile) ? resolvedOptions.packageManager.lockFile : [resolvedOptions.packageManager.lockFile];
+    for (const lockfile of lockfiles) {
+      if (lockfile) fs.rmSync(resolve(resolvedOptions.cwd, lockfile), { force: true });
+    }
+    await installDependencies(resolvedOptions);
+    return;
+  }
+  if (isSupported) {
+    const isyarnv1 = resolvedOptions.packageManager.name === "yarn" && resolvedOptions.packageManager.majorVersion === "1";
+    await executeCommand(
+      resolvedOptions.packageManager.command,
+      [isyarnv1 ? "install" : "dedupe"],
+      {
+        cwd: resolvedOptions.cwd,
+        silent: resolvedOptions.silent
+      }
+    );
+    return;
+  }
+  throw new Error(`Deduplication is not supported for ${resolvedOptions.packageManager.name}`);
+}
+export async function updateDependencies(latest = true, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  await executeCommand(
+    resolvedOptions.packageManager.command,
+    latest ? ["update", "--latest"] : ["update"],
+    {
+      cwd: resolvedOptions.cwd,
+      silent: resolvedOptions.silent
+    }
+  );
+}
+export async function runScript(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const args = [resolvedOptions.packageManager.name === "deno" ? "task" : "run", name];
+  await executeCommand(resolvedOptions.packageManager.command, args, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}

package/bin/app/utils/pm/pm-meta.js

@@ -0,0 +1,86 @@
+import ky from "ky";
+import registryAuthToken from "registry-auth-token";
+import registryUrl from "registry-url";
+import semver from "semver";
+export class PackageNotFoundError extends Error {
+  constructor(packageName) {
+    super(`Package \`${packageName}\` could not be found`);
+    this.name = "PackageNotFoundError";
+  }
+}
+export class VersionNotFoundError extends Error {
+  constructor(packageName, version) {
+    super(`Version \`${version}\` for package \`${packageName}\` could not be found`);
+    this.name = "VersionNotFoundError";
+  }
+}
+export async function pmPackageJson(packageName, options = {}) {
+  let { version = "latest" } = options;
+  const { omitDeprecated = true } = options;
+  const scope = packageName.split("/")[0];
+  const registryUrl_ = options.registryUrl ?? registryUrl(scope);
+  const packageUrl = new URL(encodeURIComponent(packageName).replace(/^%40/, "@"), registryUrl_);
+  const authInfo = registryAuthToken(registryUrl_.toString(), { recursive: true });
+  const headers = {
+    accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+  };
+  if (options.fullMetadata) {
+    headers.accept = "";
+  }
+  if (authInfo) {
+    headers.authorization = `${authInfo.type} ${authInfo.token}`;
+  }
+  let data;
+  try {
+    data = await ky(packageUrl, { headers, keepalive: true }).json();
+  } catch (error) {
+    if (error?.response?.status === 404) {
+      throw new PackageNotFoundError(packageName);
+    }
+    throw error;
+  }
+  if (options.allVersions) {
+    return data;
+  }
+  const versionError = new VersionNotFoundError(packageName, version);
+  if (version && data["dist-tags"][version]) {
+    const { time } = data;
+    const versionTag = data["dist-tags"][version];
+    if (versionTag) {
+      const packageVersion = data.versions[versionTag];
+      if (packageVersion) {
+        packageVersion.time = time;
+        return packageVersion;
+      }
+    }
+  } else if (version) {
+    const versionExists = Boolean(data.versions[version]);
+    if (omitDeprecated && !versionExists) {
+      for (const [metadataVersion, metadata] of Object.entries(data.versions)) {
+        if (metadata.deprecated) {
+          delete data.versions[metadataVersion];
+        }
+      }
+    }
+    if (!versionExists) {
+      const versions = Object.keys(data.versions);
+      const resolvedVersion = semver.maxSatisfying(versions, version);
+      if (!resolvedVersion) {
+        throw versionError;
+      }
+      version = resolvedVersion;
+    }
+    const { time } = data;
+    const packageVersion = data.versions[version];
+    if (!packageVersion) {
+      throw versionError;
+    }
+    packageVersion.time = time;
+    return packageVersion;
+  }
+  throw versionError;
+}
+export async function latestVersion(packageName, options = {}) {
+  const { version } = await pmPackageJson(packageName.toLowerCase(), options);
+  return version;
+}

package/bin/app/utils/pm/pm-utils.js

@@ -0,0 +1,115 @@
+import { createRequire } from "node:module";
+import { resolve } from "@reliverse/pathkit";
+import { x } from "../exec/exec-mod.js";
+import { detectPackageManager, packageManagers } from "./pm-detect.js";
+function cached(fn) {
+  let v;
+  return () => {
+    if (v === void 0) {
+      v = fn().then((r) => {
+        v = r;
+        return v;
+      });
+    }
+    return v;
+  };
+}
+const hasCorepack = cached(async () => {
+  if (globalThis.process?.versions?.webcontainer) {
+    return false;
+  }
+  try {
+    const { exitCode } = await x("corepack", ["--version"]);
+    return exitCode === 0;
+  } catch {
+    return false;
+  }
+});
+export async function executeCommand(command, args, options = {}) {
+  console.log("DEBUG: executeCommand called with:", {
+    command,
+    args,
+    options,
+    commandType: typeof command,
+    argsType: typeof args,
+    isArgsArray: Array.isArray(args)
+  });
+  if (!Array.isArray(args)) {
+    throw new Error(`executeCommand: args must be an array, got ${typeof args}: ${args}`);
+  }
+  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  console.log("DEBUG: executeCommand xArgs:", {
+    xArgs,
+    command: xArgs[0],
+    args: xArgs[1],
+    commandType: typeof xArgs[0],
+    argsType: typeof xArgs[1],
+    isArgsArray: Array.isArray(xArgs[1])
+  });
+  const { exitCode, stdout, stderr } = await x(xArgs[0], xArgs[1], {
+    nodeOptions: {
+      cwd: resolve(options.cwd || process.cwd()),
+      stdio: options.silent ? "pipe" : "inherit"
+    }
+  });
+  if (exitCode !== 0) {
+    throw new Error(
+      `\`${xArgs.flat().join(" ")}\` failed.${options.silent ? ["", stdout, stderr].join("\n") : ""}`
+    );
+  }
+}
+export const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
+export async function resolveOperationOptions(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const packageManager = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
+  if (!packageManager) {
+    throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
+  }
+  return {
+    cwd,
+    silent: options.silent ?? false,
+    packageManager,
+    dev: options.dev ?? false,
+    workspace: options.workspace,
+    filter: options.filter,
+    asCatalog: options.asCatalog,
+    catalogName: options.catalogName,
+    global: options.global ?? false
+  };
+}
+export function getWorkspaceArgs(options) {
+  const args = [];
+  if (options.filter && options.filter.length > 0) {
+    for (const filter of options.filter) {
+      args.push("--filter", filter);
+    }
+    return args;
+  }
+  if (!options.workspace) {
+    return [];
+  }
+  const workspacePkg = typeof options.workspace === "string" && options.workspace !== "" ? options.workspace : void 0;
+  if (options.packageManager.name === "pnpm") {
+    return workspacePkg ? ["--filter", workspacePkg] : ["--workspace-root"];
+  }
+  if (options.packageManager.name === "npm") {
+    return workspacePkg ? ["-w", workspacePkg] : ["--workspaces"];
+  }
+  if (options.packageManager.name === "yarn") {
+    if (!options.packageManager.majorVersion || options.packageManager.majorVersion === "1") {
+      return workspacePkg ? ["--cwd", workspacePkg] : ["-W"];
+    } else {
+      return workspacePkg ? ["workspace", workspacePkg] : [];
+    }
+  }
+  return [];
+}
+export function doesDependencyExist(name, options) {
+  const require = createRequire(options.cwd.endsWith("/") ? options.cwd : options.cwd + "/");
+  try {
+    const resolvedPath = require.resolve(name);
+    return resolvedPath.startsWith(options.cwd);
+  } catch {
+    return false;
+  }
+}

package/bin/app/utils/projectRepository.d.ts

@@ -0,0 +1,59 @@
+import type { Static } from "@sinclair/typebox";
+import { rseSchema } from "../config/cfg-schema.js";
+import { type RepoInfo } from "./schemaTemplate";
+export type RepoFromSchema = NonNullable<Static<(typeof rseSchema)["properties"]["projectTemplate"]>>;
+export type CategoryFromSchema = NonNullable<Static<(typeof rseSchema)["properties"]["projectCategory"]>>;
+export interface CloneOrTemplateRepo {
+    id: RepoFromSchema;
+    author: string;
+    name: string;
+    description: string;
+    category: CategoryFromSchema;
+}
+export type RepoOption = CloneOrTemplateRepo["id"] | "unknown";
+export declare const REPO_TEMPLATES: CloneOrTemplateRepo[];
+export declare function getRepoInfo(repoId: string): Promise<RepoInfo | null>;
+export declare function saveRepoToDevice(repo: CloneOrTemplateRepo, projectPath: string): Promise<void>;
+export declare const TEMP_FULLSTACK_WEBSITE_TEMPLATE_OPTIONS: {
+    readonly "blefnk/relivator-nextjs-template": {
+        readonly label: `Relivator ${any}`;
+        readonly value: "blefnk/relivator-nextjs-template";
+        readonly hint: any;
+    };
+    readonly "blefnk/versator-nextjs-template": {
+        readonly label: `Versator ${any}`;
+        readonly value: "blefnk/versator-nextjs-template";
+        readonly hint: any;
+    };
+    readonly "blefnk/next-react-ts-src-minimal": {
+        readonly label: `Next.js Only ${any}`;
+        readonly value: "blefnk/next-react-ts-src-minimal";
+        readonly hint: any;
+    };
+};
+export declare const TEMP_SEPARATED_WEBSITE_TEMPLATE_OPTIONS: {
+    "blefnk/relivator-docker-repo": {
+        label: string;
+        value: string;
+        hint: any;
+    };
+};
+export declare const TEMP_VSCODE_TEMPLATE_OPTIONS: {
+    readonly "microsoft/vscode-extension-samples": {
+        readonly label: "VS Code Extension Sample";
+        readonly value: "microsoft/vscode-extension-samples";
+        readonly hint: any;
+    };
+    readonly "microsoft/vscode-extension-template": {
+        readonly label: "VS Code Extension Template";
+        readonly value: "microsoft/vscode-extension-template";
+        readonly hint: any;
+    };
+};
+export declare const TEMP_BROWSER_TEMPLATE_OPTIONS: {
+    "rsebrowser-extension": {
+        label: string;
+        value: string;
+        hint: any;
+    };
+};