@reliverse/dler 1.7.121 → 1.7.123

package/bin/impl/utils/spinner.js

@@ -1,54 +1,370 @@
-export class SimpleSpinner {
-  interval;
-  message;
-  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  // biome-ignore lint/style/useReadonlyClassProperties: <false positive probably>
-  currentFrame = 0;
-  isSpinning = false;
-  constructor(message) {
-    this.message = message;
+import cliSpinners, { randomSpinner } from "cli-spinners";
+import ora, {
+  oraPromise
+} from "ora";
+import prettyBytes from "pretty-bytes";
+import prettyMilliseconds from "pretty-ms";
+function isCIEnvironment() {
+  const { CI, GITHUB_ACTIONS, BUILD_NUMBER, RUN_ID } = process.env;
+  return CI === "true" || GITHUB_ACTIONS === "true" || typeof BUILD_NUMBER !== "undefined" || typeof RUN_ID !== "undefined";
+}
+const defaultStderr = process.stderr;
+function isInteractive(stream = defaultStderr) {
+  return Boolean(stream && stream.isTTY);
+}
+function getDefaultEnabled(stream = defaultStderr) {
+  const disabledByEnv = process.env.DLER_NO_SPINNER === "1" || process.env.NO_COLOR === "1";
+  if (disabledByEnv) return false;
+  if (isCIEnvironment()) return false;
+  return isInteractive(stream);
+}
+export const defaultSpinnerOptions = {
+  color: "cyan",
+  spinner: "dots",
+  hideCursor: true,
+  indent: 0,
+  discardStdin: true,
+  respectEnv: true,
+  showTiming: false
+};
+export function isSpinnerEnabled(options) {
+  const stream = options?.stream ?? defaultStderr;
+  const respectEnv = options?.respectEnv !== false;
+  if (typeof options?.isEnabled === "boolean") return options.isEnabled;
+  return respectEnv ? getDefaultEnabled(stream) : true;
+}
+export function createSpinner(input) {
+  const base = typeof input === "string" ? { text: input } : { ...input ?? {} };
+  const stream = base.stream ?? defaultStderr;
+  const respectEnv = base.respectEnv !== false;
+  const isEnabled = base.isEnabled ?? (respectEnv ? getDefaultEnabled(stream) : true);
+  const isSilent = base.isSilent ?? false;
+  return ora({
+    // Defaults chosen to be broadly useful; callers can override
+    color: base.color ?? defaultSpinnerOptions.color,
+    spinner: base.spinner ?? defaultSpinnerOptions.spinner,
+    hideCursor: base.hideCursor ?? defaultSpinnerOptions.hideCursor,
+    indent: base.indent ?? defaultSpinnerOptions.indent,
+    interval: base.interval,
+    prefixText: base.prefixText,
+    suffixText: base.suffixText,
+    stream,
+    text: base.text,
+    isEnabled,
+    isSilent,
+    discardStdin: base.discardStdin ?? defaultSpinnerOptions.discardStdin
+  });
+}
+export async function withSpinnerPromise(action, options) {
+  return oraPromise(
+    action,
+    options
+  );
+}
+export async function withSpinner(textOrOptions, action, onSuccessText, onFailText) {
+  const startTime = Date.now();
+  const options = typeof textOrOptions === "string" ? { text: textOrOptions } : textOrOptions;
+  const spinner = createSpinner(textOrOptions).start();
+  try {
+    const result = await action(spinner);
+    const successMsg = getSuccessMessage(result, onSuccessText, options, startTime);
+    spinner.succeed(successMsg);
+    return result;
+  } catch (error) {
+    const err = error;
+    const failMsg = getFailMessage(err, onFailText, options);
+    spinner.fail(failMsg);
+    throw err;
   }
-  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;
+}
+function getSuccessMessage(result, onSuccessText, options, startTime) {
+  let message;
+  if (typeof onSuccessText === "function") {
+    message = onSuccessText(result);
+  } else if (typeof onSuccessText === "string") {
+    message = onSuccessText;
+  } else if (options.defaultSuccess) {
+    message = options.defaultSuccess;
   }
-  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;
+  if (options.showTiming && message) {
+    const elapsed = Date.now() - startTime;
+    const timing = prettyMilliseconds(elapsed, { compact: true });
+    message = `${message} (${timing})`;
   }
-  updateMessage(message) {
-    this.message = message;
-    return this;
+  return message;
+}
+function getFailMessage(error, onFailText, options) {
+  if (typeof onFailText === "function") {
+    return onFailText(error);
+  } else if (typeof onFailText === "string") {
+    return onFailText;
+  } else if (options.defaultFail) {
+    return options.defaultFail;
   }
-  succeed(message) {
-    return this.stop(message ? `\u2705 ${message}` : `\u2705 ${this.message}`);
+}
+export function updateSpinnerText(spinner, text, options) {
+  const { prefix, suffix } = options ?? {};
+  const fullText = `${prefix ?? ""}${text}${suffix ?? ""}`;
+  spinner.text = fullText;
+}
+export function stopAndPersist(spinner, options) {
+  spinner.stopAndPersist({
+    symbol: options.symbol ?? " ",
+    text: options.text ?? spinner.text,
+    prefixText: options.prefixText ?? spinner.prefixText,
+    suffixText: options.suffixText ?? spinner.suffixText
+  });
+}
+export function createTimedSpinner(input) {
+  const startTime = Date.now();
+  const options = typeof input === "string" ? { text: input } : { ...input ?? {} };
+  const spinner = createSpinner({ ...options, showTiming: true });
+  return {
+    spinner,
+    getElapsed: () => Date.now() - startTime,
+    succeedWithTiming: (text) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const message = text ? `${text} (${timing})` : void 0;
+      spinner.succeed(message);
+    },
+    failWithTiming: (text) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const message = text ? `${text} (failed after ${timing})` : void 0;
+      spinner.fail(message);
+    }
+  };
+}
+export function createSpinnerGroup(options) {
+  const { items, concurrent = false, ...baseOptions } = options;
+  const spinners2 = items.map((item, index) => {
+    const spinnerOptions = {
+      ...baseOptions,
+      text: item,
+      indent: (baseOptions.indent ?? 0) + (concurrent ? 0 : index * 2)
+    };
+    return createSpinner(spinnerOptions);
+  });
+  return {
+    spinners: spinners2,
+    updateAll: (text) => {
+      for (const spinner of spinners2) {
+        spinner.text = text;
+      }
+    },
+    succeedAll: (text) => {
+      for (const spinner of spinners2) {
+        spinner.succeed(text);
+      }
+    },
+    failAll: (text) => {
+      for (const spinner of spinners2) {
+        spinner.fail(text);
+      }
+    },
+    stopAll: () => {
+      for (const spinner of spinners2) {
+        spinner.stop();
+      }
+    }
+  };
+}
+export async function withEnhancedSpinner(textOrOptions, action) {
+  const startTime = Date.now();
+  const options = typeof textOrOptions === "string" ? { text: textOrOptions, showTiming: false } : { showTiming: false, ...textOrOptions };
+  const baseSpinner = createSpinner(options).start();
+  const enhancedSpinner = Object.assign(baseSpinner, {
+    updateText: (text, updateOptions) => {
+      updateSpinnerText(baseSpinner, text, updateOptions);
+    },
+    setProgress: (current, total, text) => {
+      const progressText = text ? `${text} (${current}/${total})` : `${current}/${total}`;
+      baseSpinner.text = progressText;
+    }
+  });
+  try {
+    const result = await action(enhancedSpinner);
+    let successText = options.successText;
+    if (options.showTiming && successText) {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      successText = `${successText} (${timing})`;
+    }
+    baseSpinner.succeed(successText);
+    return result;
+  } catch (error) {
+    const err = error;
+    let failText = options.failText;
+    if (options.showTiming && failText) {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      failText = `${failText} (failed after ${timing})`;
+    }
+    baseSpinner.fail(failText);
+    throw err;
   }
-  fail(message) {
-    return this.stop(message ? `\u274C ${message}` : `\u274C ${this.message}`);
+}
+export function isSpinnerRunning(spinner) {
+  return spinner.isSpinning;
+}
+export function safeStopSpinner(spinner) {
+  if (spinner?.isSpinning) {
+    spinner.stop();
   }
 }
-export function createSpinner(message) {
-  return new SimpleSpinner(message);
+export function createBuildSpinner(operation, options) {
+  const spinner = createSpinner({ text: operation, ...options }).start();
+  return {
+    spinner,
+    complete: (message) => {
+      spinner.succeed(message ?? `${operation} completed successfully!`);
+    },
+    error: (error) => {
+      const errorMessage = typeof error === "string" ? error : error.message;
+      spinner.fail(`${operation} failed: ${errorMessage}`);
+    },
+    updateProgress: (step) => {
+      spinner.text = `${operation} - ${step}`;
+    }
+  };
+}
+export function createFileProgressSpinner(operation, options) {
+  const { totalBytes, showBytes = true, showRate = false, ...spinnerOptions } = options ?? {};
+  const startTime = Date.now();
+  const spinner = createSpinner({ text: operation, ...spinnerOptions }).start();
+  return {
+    spinner,
+    updateProgress: (bytesProcessed, fileName) => {
+      let progressText = operation;
+      if (fileName) {
+        progressText += ` - ${fileName}`;
+      }
+      if (showBytes) {
+        if (totalBytes) {
+          const percentage = Math.round(bytesProcessed / totalBytes * 100);
+          progressText += ` (${prettyBytes(bytesProcessed)}/${prettyBytes(totalBytes)} - ${percentage}%)`;
+        } else {
+          progressText += ` (${prettyBytes(bytesProcessed)})`;
+        }
+      }
+      spinner.text = progressText;
+    },
+    updateRate: (bytesPerSecond) => {
+      if (showRate) {
+        const currentText = spinner.text;
+        const rateText = `${prettyBytes(bytesPerSecond)}/s`;
+        spinner.text = `${currentText} @ ${rateText}`;
+      }
+    },
+    complete: (message) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const successMessage = message ?? `${operation} completed successfully`;
+      spinner.succeed(`${successMessage} (${timing})`);
+    },
+    error: (error) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      spinner.fail(`${operation} failed: ${errorMessage} (after ${timing})`);
+    }
+  };
+}
+export function createMultiStepSpinner(operationName, steps, options) {
+  const startTime = Date.now();
+  let currentStepIndex = 0;
+  const totalSteps = steps.length;
+  const getStepText = (stepIndex) => {
+    const step = steps[stepIndex];
+    return `${operationName} - ${step} (${stepIndex + 1}/${totalSteps})`;
+  };
+  const spinner = createSpinner({ text: getStepText(0), ...options }).start();
+  return {
+    spinner,
+    nextStep: (stepIndex) => {
+      if (stepIndex !== void 0) {
+        currentStepIndex = Math.min(stepIndex, totalSteps - 1);
+      } else {
+        currentStepIndex = Math.min(currentStepIndex + 1, totalSteps - 1);
+      }
+      spinner.text = getStepText(currentStepIndex);
+    },
+    complete: (message) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const successMessage = message ?? `${operationName} completed successfully`;
+      spinner.succeed(`${successMessage} (${timing})`);
+    },
+    error: (error, stepIndex) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      const stepInfo = stepIndex !== void 0 ? ` at step ${stepIndex + 1}` : "";
+      spinner.fail(`${operationName} failed${stepInfo}: ${errorMessage} (after ${timing})`);
+    },
+    getCurrentStep: () => currentStepIndex
+  };
+}
+export function formatSpinnerTiming(startTime, options) {
+  const elapsed = Date.now() - startTime;
+  return prettyMilliseconds(elapsed, {
+    compact: !options?.verbose,
+    verbose: options?.verbose
+  });
+}
+export function formatSpinnerBytes(bytes, options) {
+  return prettyBytes(bytes, options);
+}
+export function formatSpinnerElapsed(elapsed, options) {
+  return prettyMilliseconds(elapsed, {
+    compact: !options?.verbose,
+    verbose: options?.verbose
+  });
+}
+export function createTransferSpinner(operation, options) {
+  const { totalBytes, showRate = true, ...spinnerOptions } = options ?? {};
+  const startTime = Date.now();
+  const spinner = createSpinner({ text: operation, ...spinnerOptions }).start();
+  return {
+    spinner,
+    updateBytes: (bytesTransferred, fileName) => {
+      let text = operation;
+      if (fileName) {
+        text += ` - ${fileName}`;
+      }
+      if (totalBytes) {
+        const percentage = Math.round(bytesTransferred / totalBytes * 100);
+        text += ` (${prettyBytes(bytesTransferred)}/${prettyBytes(totalBytes)} - ${percentage}%)`;
+      } else {
+        text += ` (${prettyBytes(bytesTransferred)})`;
+      }
+      spinner.text = text;
+    },
+    updateRate: (bytesPerSecond) => {
+      if (showRate) {
+        const currentText = spinner.text;
+        const rateText = `${prettyBytes(bytesPerSecond)}/s`;
+        spinner.text = `${currentText} @ ${rateText}`;
+      }
+    },
+    complete: (message, totalBytesTransferred) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      let successMessage = message ?? `${operation} completed successfully`;
+      if (totalBytesTransferred) {
+        successMessage += ` (${prettyBytes(totalBytesTransferred)})`;
+      }
+      successMessage += ` in ${timing}`;
+      spinner.succeed(successMessage);
+    },
+    error: (error) => {
+      const elapsed = Date.now() - startTime;
+      const timing = prettyMilliseconds(elapsed, { compact: true });
+      const errorMessage = typeof error === "string" ? error : error.message;
+      spinner.fail(`${operation} failed: ${errorMessage} (after ${timing})`);
+    }
+  };
 }
+export const spinners = cliSpinners;
+export { randomSpinner, prettyBytes, prettyMilliseconds };

package/bin/mod.d.ts

@@ -158,8 +158,8 @@ export { createMobileProject, createWebProject } from "./impl/init/use-template/
 export { showCloneProjectMenu } from "./impl/init/use-template/cp-modules/cli-main-modules/cli-menu-items/showCloneProjectMenu";
 export { showAnykeyPrompt } from "./impl/init/use-template/cp-modules/cli-main-modules/modules/showAnykeyPrompt";
 export { copyFromExisting, ensureEnvExists, ensureExampleExists, fetchEnvExampleContent, getEnvPath, getLastEnvFilePath, getMissingKeys, promptAndSetMissingValues, saveLastEnvFilePath, } from "./impl/init/use-template/cp-modules/compose-env-file/cef-impl";
-export type { KeyType, KnownService, } from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys";
-export { dashboards, defaultValues, KNOWN_SERVICES, keyTypeSchema, keyVarsSchema, knownServiceSchema, serviceKeySchema, } from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys";
+export type { DashboardUrl, DefaultValue, KeyType, KeyVar, KnownService, ServiceKey, } from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys";
+export { KNOWN_SERVICES } from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys";
 export { composeEnvFile } from "./impl/init/use-template/cp-modules/compose-env-file/cef-mod";
 export { deployProject, selectDeploymentService, } from "./impl/init/use-template/cp-modules/git-deploy-prompts/deploy";
 export { configureGithubRepo, handleGitInit, promptGitDeploy, } from "./impl/init/use-template/cp-modules/git-deploy-prompts/gdp-mod";
@@ -408,14 +408,14 @@ export { getOrCreateReliverseMemory, updateReliverseMemory } from "./impl/utils/
 export type { ReplaceConfig } from "./impl/utils/replacements/reps-impl";
 export { extractRepoInfo, replaceStringsInFiles } from "./impl/utils/replacements/reps-impl";
 export type { Hardcoded, UrlPatterns } from "./impl/utils/replacements/reps-keys";
-export { CommonPatterns, HardcodedStrings, hardcodedSchema, urlPatternsSchema, } from "./impl/utils/replacements/reps-keys";
+export { CommonPatterns, HardcodedStrings, } from "./impl/utils/replacements/reps-keys";
 export { handleReplacements } from "./impl/utils/replacements/reps-mod";
 export { resolveAllCrossLibs } from "./impl/utils/resolve-cross-libs";
-export type { EncryptedDataMemory, ReliverseMemory, UserDataMemory, } from "./impl/utils/schemaMemory";
-export { memorySchema } from "./impl/utils/schemaMemory";
+export type { EncryptedDataMemory, EncryptedDataMemoryShape, ReliverseMemory, UserDataMemory, UserDataMemoryShape, } from "./impl/utils/schemaMemory";
 export type { RepoInfo, ReposConfig } from "./impl/utils/schemaTemplate";
-export { DEFAULT_REPOS_CONFIG, generateReposJsonSchema, repoInfoSchema, reposSchema, shouldRegenerateSchema, } from "./impl/utils/schemaTemplate";
-export { createSpinner, SimpleSpinner } from "./impl/utils/spinner";
+export { DEFAULT_REPOS_CONFIG, generateReposJsonSchema, isReposConfig, shouldRegenerateSchema, } from "./impl/utils/schemaTemplate";
+export type { FileProgressOptions, SimpleSpinner, SpinnerGroupOptions, SpinnerOptions, } from "./impl/utils/spinner";
+export { createBuildSpinner, createFileProgressSpinner, createMultiStepSpinner, createSpinner, createSpinnerGroup, createTimedSpinner, createTransferSpinner, defaultSpinnerOptions, formatSpinnerBytes, formatSpinnerElapsed, formatSpinnerTiming, isSpinnerEnabled, isSpinnerRunning, prettyBytes, prettyMilliseconds, randomSpinner, safeStopSpinner, spinners, stopAndPersist, updateSpinnerText, withEnhancedSpinner, withSpinner, withSpinnerPromise, } from "./impl/utils/spinner";
 export { getPkgName, getPkgVersion, readPackageJSON, showEndPrompt, showStartPrompt, } from "./impl/utils/startEndPrompts";
 export { cd, getCurrentWorkingDirectory, handleError, pwd, rm, } from "./impl/utils/terminalHelpers";
 export { setupDevModeIfNeeded } from "./impl/utils/testsRuntime";

package/bin/mod.js

@@ -380,15 +380,7 @@ export {
   promptAndSetMissingValues,
   saveLastEnvFilePath
 } from "./impl/init/use-template/cp-modules/compose-env-file/cef-impl.js";
-export {
-  dashboards,
-  defaultValues,
-  KNOWN_SERVICES,
-  keyTypeSchema,
-  keyVarsSchema,
-  knownServiceSchema,
-  serviceKeySchema
-} from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys.js";
+export { KNOWN_SERVICES } from "./impl/init/use-template/cp-modules/compose-env-file/cef-keys.js";
 export { composeEnvFile } from "./impl/init/use-template/cp-modules/compose-env-file/cef-mod.js";
 export {
   deployProject,
@@ -970,21 +962,41 @@ export { getOrCreateReliverseMemory, updateReliverseMemory } from "./impl/utils/
 export { extractRepoInfo, replaceStringsInFiles } from "./impl/utils/replacements/reps-impl.js";
 export {
   CommonPatterns,
-  HardcodedStrings,
-  hardcodedSchema,
-  urlPatternsSchema
+  HardcodedStrings
 } from "./impl/utils/replacements/reps-keys.js";
 export { handleReplacements } from "./impl/utils/replacements/reps-mod.js";
 export { resolveAllCrossLibs } from "./impl/utils/resolve-cross-libs.js";
-export { memorySchema } from "./impl/utils/schemaMemory.js";
 export {
   DEFAULT_REPOS_CONFIG,
   generateReposJsonSchema,
-  repoInfoSchema,
-  reposSchema,
+  isReposConfig,
   shouldRegenerateSchema
 } from "./impl/utils/schemaTemplate.js";
-export { createSpinner, SimpleSpinner } from "./impl/utils/spinner.js";
+export {
+  createBuildSpinner,
+  createFileProgressSpinner,
+  createMultiStepSpinner,
+  createSpinner,
+  createSpinnerGroup,
+  createTimedSpinner,
+  createTransferSpinner,
+  defaultSpinnerOptions,
+  formatSpinnerBytes,
+  formatSpinnerElapsed,
+  formatSpinnerTiming,
+  isSpinnerEnabled,
+  isSpinnerRunning,
+  prettyBytes,
+  prettyMilliseconds,
+  randomSpinner,
+  safeStopSpinner,
+  spinners,
+  stopAndPersist,
+  updateSpinnerText,
+  withEnhancedSpinner,
+  withSpinner,
+  withSpinnerPromise
+} from "./impl/utils/spinner.js";
 export {
   getPkgName,
   getPkgVersion,

package/package.json

@@ -5,7 +5,7 @@
     "@babel/preset-typescript": "^7.27.1",
     "@hookform/resolvers": "^5.2.1",
     "@libsql/client": "^0.15.14",
-    "@mendable/firecrawl-js": "^3.2.1",
+    "@mendable/firecrawl-js": "^3.3.0",
     "@mrleebo/prisma-ast": "^0.13.0",
     "@octokit/plugin-rest-endpoint-methods": "^16.0.0",
     "@octokit/request-error": "^7.0.0",
@@ -27,13 +27,12 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-replace": "^6.0.2",
     "@rollup/pluginutils": "^5.2.0",
-    "@sinclair/typebox": "^0.34.40",
     "@uploadcare/upload-client": "^6.17.0",
     "@vercel/sdk": "^1.10.6",
     "@volar/typescript": "^2.4.23",
     "@vue/language-core": "^3.0.6",
     "@vue/language-core2.0": "npm:@vue/language-core@2.0.29",
-    "ai": "^5.0.25",
+    "ai": "^5.0.26",
     "async-listen": "^3.1.0",
     "autoprefixer": "^10.4.21",
     "better-auth": "^1.3.7",
@@ -84,7 +83,7 @@
     "postcss": "^8.5.6",
     "postcss-nested": "^7.0.2",
     "postgres": "^3.4.7",
-    "posthog-node": "^5.8.0",
+    "posthog-node": "^5.8.1",
     "pretty-bytes": "^7.0.1",
     "pretty-ms": "^9.2.0",
     "querystring": "^0.2.1",
@@ -94,7 +93,7 @@
     "react-hook-form": "^7.62.0",
     "registry-auth-token": "^5.1.0",
     "registry-url": "^7.2.0",
-    "rollup": "^4.48.1",
+    "rollup": "^4.49.0",
     "rollup-plugin-dts": "^6.2.3",
     "sass": "^1.91.0",
     "scule": "^1.3.0",
@@ -124,7 +123,7 @@
   "license": "MIT",
   "name": "@reliverse/dler",
   "type": "module",
-  "version": "1.7.121",
+  "version": "1.7.123",
   "author": "reliverse",
   "bugs": {
     "email": "blefnk@gmail.com",

package/bin/impl/config/impl/typebox.d.ts

@@ -1,8 +0,0 @@
-/**
- * Generates a JSON schema file from the TypeBox schema
- */
-export declare function generateJsonSchema(typeboxSchema: any, outputPath: string): Promise<void>;
-/**
- * Generates the schema.json in the project root
- */
-export declare function generateSchemaFile(schema: any): Promise<void>;

package/bin/impl/config/impl/typebox.js

@@ -1,82 +0,0 @@
-import path from "@reliverse/pathkit";
-import fs from "@reliverse/relifso";
-function convertTypeBoxToJsonSchema(schema) {
-  if (!schema || typeof schema !== "object") return schema;
-  if (schema.type === "string" && schema.enum) {
-    return {
-      type: "string",
-      enum: schema.enum
-    };
-  }
-  if (schema.anyOf || schema.allOf || schema.oneOf) {
-    const variants = schema.anyOf || schema.allOf || schema.oneOf;
-    const allLiterals = variants.every((v) => v.const !== void 0);
-    if (allLiterals) {
-      return {
-        type: "string",
-        enum: variants.map((v) => v.const)
-      };
-    }
-  }
-  if (schema.type === "object") {
-    const result = {
-      type: "object",
-      properties: {}
-    };
-    if (schema.required) {
-      result.required = schema.required;
-    }
-    if (schema.properties) {
-      for (const [key, value] of Object.entries(schema.properties)) {
-        result.properties[key] = convertTypeBoxToJsonSchema(value);
-      }
-    }
-    if (schema.additionalProperties) {
-      result.additionalProperties = convertTypeBoxToJsonSchema(schema.additionalProperties);
-    }
-    if (schema.patternProperties) {
-      result.patternProperties = {};
-      for (const [pattern, value] of Object.entries(schema.patternProperties)) {
-        result.patternProperties[pattern] = convertTypeBoxToJsonSchema(value);
-      }
-    }
-    return result;
-  }
-  if (schema.type === "array") {
-    return {
-      type: "array",
-      items: convertTypeBoxToJsonSchema(schema.items)
-    };
-  }
-  if (schema.type) {
-    const result = { type: schema.type };
-    if (schema.minimum !== void 0) result.minimum = schema.minimum;
-    if (schema.maximum !== void 0) result.maximum = schema.maximum;
-    if (schema.minLength !== void 0) result.minLength = schema.minLength;
-    if (schema.maxLength !== void 0) result.maxLength = schema.maxLength;
-    if (schema.pattern !== void 0) result.pattern = schema.pattern;
-    if (schema.format !== void 0) result.format = schema.format;
-    if (schema.default !== void 0) result.default = schema.default;
-    return result;
-  }
-  return schema;
-}
-export async function generateJsonSchema(typeboxSchema, outputPath) {
-  const converted = convertTypeBoxToJsonSchema(typeboxSchema);
-  const schema = {
-    $schema: "http://json-schema.org/draft-07/schema#",
-    title: "rse configuration schema",
-    description: "https://docs.reliverse.org",
-    type: "object",
-    properties: converted.properties,
-    required: converted.required
-  };
-  await fs.writeFile(outputPath, JSON.stringify(schema, null, 2));
-}
-export async function generateSchemaFile(schema) {
-  const schemaPath = path.join(process.cwd(), "schema.json");
-  if (fs.existsSync(schemaPath)) {
-    await fs.remove(schemaPath);
-  }
-  await generateJsonSchema(schema, schemaPath);
-}