@rynt/sdk 0.9.53

package/src/shared/utils/build-files.ts

@@ -0,0 +1,439 @@
+import type { BuildVersionManifest } from '../minecraft-types/build-manifest';
+import { getBuildDirectory } from './local-mods';
+
+// Проверка на наличие Node.js окружения (NW.js)
+const isNodeEnv = typeof window !== 'undefined' && (window as any).nw;
+
+// Динамическая загрузка Node.js модулей
+let fs: any;
+let path: any;
+
+if (isNodeEnv) {
+  try {
+    const nw = (window as any).nw;
+    fs = nw.require('fs');
+    path = nw.require('path');
+  } catch (error) {
+    console.error('Не удалось загрузить Node.js модули:', error);
+  }
+}
+
+/**
+ * Категория файла
+ */
+export type FileCategory =
+  | 'included'
+  | 'ignored'
+  | 'selectable'
+  | 'unavailable';
+
+/**
+ * Информация о файле в дереве файлов
+ */
+export interface BuildFileInfo {
+  /**
+   * Путь относительно директории сборки
+   */
+  path: string;
+
+  /**
+   * Полный путь к файлу
+   */
+  fullPath: string;
+
+  /**
+   * Имя файла или директории
+   */
+  name: string;
+
+  /**
+   * Это директория?
+   */
+  isDirectory: boolean;
+
+  /**
+   * Размер файла в байтах (только для файлов)
+   */
+  size?: number;
+
+  /**
+   * Категория файла
+   */
+  category: FileCategory;
+
+  /**
+   * Выбран ли файл для включения в сборку
+   */
+  selected: boolean;
+
+  /**
+   * Пропускать проверку хеша при загрузке (для конфигов, которые игрок может редактировать)
+   */
+  skipHash?: boolean;
+
+  /**
+   * Дочерние элементы (для директорий)
+   */
+  children?: BuildFileInfo[];
+}
+
+/**
+ * Проверить, должен ли путь быть недоступен для выбора
+ */
+function isUnavailablePath(filePath: string, fileName: string): boolean {
+  if (!path) return false;
+
+  // Директории и файлы, которые нельзя выбрать
+  const unavailableItems = [
+    'saves',
+    '.fabric',
+    'logs',
+    'usercache.json',
+    'downloads',
+    'realms_persistence.json',
+  ];
+
+  // Проверяем имя файла/директории
+  if (unavailableItems.includes(fileName.toLowerCase())) {
+    return true;
+  }
+
+  // Проверяем путь (например, "saves/world1" тоже должен быть недоступен)
+  const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
+  for (const unavailable of unavailableItems) {
+    if (
+      normalizedPath.startsWith(unavailable + '/') ||
+      normalizedPath === unavailable
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Проверить, является ли путь игнорируемым по умолчанию
+ */
+function isIgnoredPath(filePath: string, fileName: string): boolean {
+  if (!path) return false;
+
+  // Файлы с расширением .disabled
+  if (fileName.endsWith('.disabled')) {
+    return true;
+  }
+
+  // Директории, начинающиеся с "." (кроме .fabric, который уже в unavailable)
+  if (fileName.startsWith('.') && fileName !== '.fabric') {
+    return true;
+  }
+
+  // Конкретные файлы и директории для игнорирования
+  const ignoredItems = ['options.txt', 'defaultconfigs'];
+
+  // Проверяем имя файла/директории
+  if (ignoredItems.includes(fileName.toLowerCase())) {
+    return true;
+  }
+
+  // Проверяем путь (например, "saves/world1" тоже должен игнорироваться)
+  const normalizedPath = filePath.replace(/\\/g, '/').toLowerCase();
+  for (const ignored of ignoredItems) {
+    if (
+      normalizedPath.startsWith(ignored + '/') ||
+      normalizedPath === ignored
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Проверить, является ли файл уже включенным в сборку
+ */
+function isIncludedFile(
+  filePath: string,
+  fileName: string,
+  manifest: BuildVersionManifest | null,
+): boolean {
+  if (!manifest || !path) return false;
+
+  // version-manifest.json всегда включен
+  if (fileName === 'version-manifest.json') {
+    return true;
+  }
+
+  // <minecraftVersion>.jar всегда включен
+  const minecraftVersion = manifest._meta?.manifest?.minecraftVersion;
+  if (minecraftVersion && fileName === `${minecraftVersion}.jar`) {
+    return true;
+  }
+
+  // Проверяем моды
+  if (manifest.mods) {
+    for (const mod of manifest.mods) {
+      for (const file of mod.files || []) {
+        const modPath = file.path || `mods/${file.filename}`;
+        if (modPath === filePath || path.basename(modPath) === fileName) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // Проверяем ресурспаки
+  if (manifest.resourcePacks) {
+    for (const rp of manifest.resourcePacks) {
+      for (const file of rp.files || []) {
+        const rpPath = file.path || `resourcepacks/${file.filename}`;
+        if (rpPath === filePath || path.basename(rpPath) === fileName) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // Проверяем шейдеры
+  if (manifest.shaderPacks) {
+    for (const sp of manifest.shaderPacks) {
+      for (const file of sp.files || []) {
+        const spPath = file.path || `shaderpacks/${file.filename}`;
+        if (spPath === filePath || path.basename(spPath) === fileName) {
+          return true;
+        }
+      }
+    }
+  }
+
+  // versionAssets не проверяем - они формируются на беке из выбранных файлов
+
+  return false;
+}
+
+/**
+ * Рекурсивно сканировать директорию и построить дерево файлов
+ */
+function scanDirectory(
+  dirPath: string,
+  relativePath: string,
+  manifest: BuildVersionManifest | null,
+  selectedFiles: Map<string, { skipHash?: boolean }>,
+): BuildFileInfo[] {
+  if (!isNodeEnv || !fs || !path) return [];
+
+  const files: BuildFileInfo[] = [];
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fileName = entry.name;
+      const fullPath = path.join(dirPath, fileName);
+      const relativeFilePath = relativePath
+        ? `${relativePath}/${fileName}`
+        : fileName;
+
+      // Пропускаем version-manifest.json в корне (он уже включен)
+      if (relativePath === '' && fileName === 'version-manifest.json') {
+        continue;
+      }
+
+      const isDir = entry.isDirectory();
+      let size: number | undefined;
+      let category: FileCategory;
+      let children: BuildFileInfo[] | undefined;
+
+      if (isDir) {
+        // Рекурсивно сканируем поддиректорию
+        children = scanDirectory(
+          fullPath,
+          relativeFilePath,
+          manifest,
+          selectedFiles,
+        );
+      } else {
+        // Получаем размер файла
+        try {
+          const stats = fs.statSync(fullPath);
+          size = stats.size;
+        } catch (error) {
+          console.error(
+            `Ошибка при получении размера файла ${fullPath}:`,
+            error,
+          );
+        }
+      }
+
+      // Определяем категорию
+      if (isIncludedFile(relativeFilePath, fileName, manifest)) {
+        category = 'included';
+      } else if (isUnavailablePath(relativeFilePath, fileName)) {
+        category = 'unavailable';
+      } else if (isIgnoredPath(relativeFilePath, fileName)) {
+        category = 'ignored';
+      } else {
+        category = 'selectable';
+      }
+
+      // Проверяем, выбран ли файл
+      const selectedFileInfo = selectedFiles.get(relativeFilePath);
+      const selected = !!selectedFileInfo;
+      const skipHash = selectedFileInfo?.skipHash || false;
+
+      const fileInfo: BuildFileInfo = {
+        path: relativeFilePath,
+        fullPath,
+        name: fileName,
+        isDirectory: isDir,
+        size,
+        category,
+        selected,
+        skipHash: selected ? skipHash : undefined,
+        children: isDir ? children : undefined,
+      };
+
+      files.push(fileInfo);
+    }
+  } catch (error) {
+    console.error(`Ошибка при сканировании директории ${dirPath}:`, error);
+  }
+
+  // Сортируем: сначала директории, потом файлы, по алфавиту
+  files.sort((a, b) => {
+    if (a.isDirectory !== b.isDirectory) {
+      return a.isDirectory ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+  });
+
+  return files;
+}
+
+/**
+ * Сканировать файлы сборки и построить дерево
+ */
+export function scanBuildFiles(
+  buildId: string,
+  manifest: BuildVersionManifest | null,
+  explicitBuildDir?: string,
+): BuildFileInfo[] {
+  if (!isNodeEnv || !fs || !path) {
+    throw new Error('Node.js окружение недоступно');
+  }
+
+  // Если сборка еще не сохранена (ID = '_new'), возвращаем пустой массив
+  // Файлы появятся только после первого сохранения
+  if (!buildId || buildId === '_new') {
+    return [];
+  }
+
+  const buildDir = explicitBuildDir || getBuildDirectory(buildId);
+  if (!buildDir) {
+    throw new Error('Не удалось получить путь к директории сборки');
+  }
+
+  const dirExists = fs.existsSync(buildDir);
+  if (!dirExists) {
+    // Если директория не существует, возвращаем пустой массив вместо ошибки
+    // Это может произойти, если сборка еще не была сохранена
+    return [];
+  }
+
+  try {
+    // Проверяем, что это директория
+    const stats = fs.statSync(buildDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`Путь не является директорией: ${buildDir}`);
+    }
+  } catch (error) {
+    throw new Error(
+      `Ошибка при доступе к директории ${buildDir}: ${error instanceof Error ? error.message : 'Неизвестная ошибка'}`,
+    );
+  }
+
+  // Преобразуем selectedFiles из массива объектов в Map для быстрого доступа
+  const selectedFiles = new Map<string, { skipHash?: boolean }>();
+  if (manifest?.selectedFiles) {
+    for (const file of manifest.selectedFiles) {
+      if (typeof file === 'string') {
+        // Поддержка старого формата (массив строк) для обратной совместимости
+        selectedFiles.set(file, {});
+      } else {
+        selectedFiles.set(file.path, { skipHash: file.skipHash });
+      }
+    }
+  }
+
+  // Сканируем директорию
+  return scanDirectory(buildDir, '', manifest, selectedFiles);
+}
+
+/**
+ * Вычислить общий размер выбранных файлов
+ */
+export function calculateSelectedFilesSize(files: BuildFileInfo[]): number {
+  let totalSize = 0;
+
+  function traverse(fileList: BuildFileInfo[]) {
+    for (const file of fileList) {
+      if (file.selected && !file.isDirectory && file.size) {
+        totalSize += file.size;
+      }
+      if (file.children) {
+        traverse(file.children);
+      }
+    }
+  }
+
+  traverse(files);
+  return totalSize;
+}
+
+/**
+ * Подсчитать количество выбранных файлов
+ */
+export function countSelectedFiles(files: BuildFileInfo[]): number {
+  let count = 0;
+
+  function traverse(fileList: BuildFileInfo[]) {
+    for (const file of fileList) {
+      if (file.selected && !file.isDirectory) {
+        count++;
+      }
+      if (file.children) {
+        traverse(file.children);
+      }
+    }
+  }
+
+  traverse(files);
+  return count;
+}
+
+/**
+ * Получить все выбранные файлы из дерева файлов
+ */
+export function getSelectedPaths(
+  files: BuildFileInfo[],
+): Array<{ path: string; skipHash?: boolean }> {
+  const result: Array<{ path: string; skipHash?: boolean }> = [];
+
+  function traverse(fileList: BuildFileInfo[]) {
+    for (const file of fileList) {
+      if (file.selected && !file.isDirectory) {
+        result.push({
+          path: file.path,
+          skipHash: file.skipHash || undefined,
+        });
+      }
+      if (file.children) {
+        traverse(file.children);
+      }
+    }
+  }
+
+  traverse(files);
+  return result;
+}

package/src/shared/utils/build-manifest-init.ts

@@ -0,0 +1,176 @@
+import type { BuildVersionManifest } from '../minecraft-types/build-manifest';
+import { cloneDeep } from 'lodash-es';
+
+/**
+ * Эталонный минимальный манифест сборки
+ */
+export function getDefaultBuildManifest(
+  uuid: string,
+  name: string = 'Новая сборка',
+): BuildVersionManifest {
+  const now = new Date().toISOString();
+  return {
+    id: uuid,
+    type: 'release',
+    arguments: {
+      game: [],
+      jvm: [],
+    },
+    libraries: [],
+    _meta: {
+      uuid: '',
+      name: name,
+      version: '0.0.0',
+      releaseTime: now,
+      time: now,
+      settings: {
+        javaPath: '',
+        jvmArgs: '',
+        maxRam: 2048,
+      },
+      manifest: {
+        minecraftVersion: '',
+        loader: 'vanilla',
+        loaderVersion: '',
+      },
+      description: '',
+      image: '',
+      stats: {
+        lastPlayed: '',
+        playTime: 0,
+      },
+      author: {
+        id: '',
+        username: '',
+        name: '',
+      },
+    },
+    versionAssets: [],
+    mods: [],
+    resourcePacks: [],
+    shaderPacks: [],
+    selectedFiles: [],
+  };
+}
+
+/**
+ * Инициализировать манифест сборки, мержа эталонный манифест с существующими данными
+ * @param existingManifest Существующий манифест (если есть)
+ * @param uuid UUID сборки
+ * @param name Название сборки
+ * @returns Инициализированный манифест
+ */
+export function initializeBuildManifest(
+  existingManifest: BuildVersionManifest | null,
+  uuid?: string,
+  name?: string,
+): BuildVersionManifest {
+  // Создаем эталонный манифест
+  const defaultManifest = getDefaultBuildManifest(
+    uuid || '',
+    name || existingManifest?._meta?.name || 'Новая сборка',
+  );
+
+  if (!existingManifest) {
+    // Если манифеста нет, возвращаем эталонный
+    return cloneDeep(defaultManifest);
+  }
+
+  // Клонируем существующий манифест, чтобы не изменять оригинал
+  const manifest = cloneDeep(existingManifest);
+
+  // Мержим _meta, сохраняя существующие данные
+  if (!manifest._meta) {
+    manifest._meta = cloneDeep(defaultManifest._meta);
+  } else {
+    // Мержим поля _meta, сохраняя существующие значения
+    const defaultMeta = defaultManifest._meta!;
+
+    // Убеждаемся, что обязательные поля существуют
+    if (!manifest._meta.uuid) {
+      manifest._meta.uuid = defaultMeta.uuid;
+    }
+    if (!manifest._meta.name) {
+      manifest._meta.name = defaultMeta.name;
+    }
+    if (!manifest._meta.version) {
+      manifest._meta.version = defaultMeta.version;
+    }
+    if (!manifest._meta.releaseTime) {
+      manifest._meta.releaseTime = defaultMeta.releaseTime;
+    }
+    if (!manifest._meta.time) {
+      manifest._meta.time = defaultMeta.time;
+    }
+
+    // Мержим settings
+    if (!manifest._meta.settings) {
+      manifest._meta.settings = cloneDeep(defaultMeta.settings);
+    } else {
+      // Убеждаемся, что все поля settings существуют
+      if (manifest._meta.settings.javaPath === undefined) {
+        manifest._meta.settings.javaPath = defaultMeta.settings!.javaPath;
+      }
+      if (manifest._meta.settings.jvmArgs === undefined) {
+        manifest._meta.settings.jvmArgs = defaultMeta.settings!.jvmArgs;
+      }
+      if (manifest._meta.settings.maxRam === undefined) {
+        manifest._meta.settings.maxRam = defaultMeta.settings!.maxRam;
+      }
+    }
+
+    // Мержим manifest (информация о версии Minecraft и загрузчике)
+    if (!manifest._meta.manifest) {
+      manifest._meta.manifest = cloneDeep(defaultMeta.manifest);
+    } else {
+      // Убеждаемся, что все поля manifest существуют
+      // НЕ перезаписываем, если поле уже заполнено пользователем (не пустое и не undefined)
+      if (manifest._meta.manifest.minecraftVersion === undefined) {
+        manifest._meta.manifest.minecraftVersion =
+          defaultMeta.manifest!.minecraftVersion;
+      }
+      // Если поле пустое (''), НЕ перезаписываем его дефолтным значением - это может быть намеренно
+      // Но если undefined, используем дефолтное значение
+      if (manifest._meta.manifest.loader === undefined) {
+        manifest._meta.manifest.loader = defaultMeta.manifest!.loader;
+      }
+      if (manifest._meta.manifest.loaderVersion === undefined) {
+        manifest._meta.manifest.loaderVersion =
+          defaultMeta.manifest!.loaderVersion;
+      }
+    }
+  }
+
+  // Убеждаемся, что основные поля манифеста существуют
+  if (!manifest.id) {
+    manifest.id = defaultManifest.id;
+  }
+  if (!manifest.type) {
+    manifest.type = defaultManifest.type;
+  }
+  if (!manifest.arguments) {
+    manifest.arguments = cloneDeep(defaultManifest.arguments);
+  }
+  if (!manifest.libraries) {
+    manifest.libraries = cloneDeep(defaultManifest.libraries);
+  }
+  // Сохраняем существующие mods и resourcePacks, если они есть
+  if (!manifest.mods) {
+    manifest.mods = [];
+  }
+  if (!manifest.resourcePacks) {
+    manifest.resourcePacks = [];
+  }
+  if (!manifest.shaderPacks) {
+    manifest.shaderPacks = [];
+  }
+  if (!manifest.versionAssets) {
+    manifest.versionAssets = [];
+  }
+  // Инициализируем selectedFiles, если его нет
+  if (!manifest.selectedFiles) {
+    manifest.selectedFiles = [];
+  }
+
+  return manifest;
+}

package/src/shared/utils/cloudinary.ts

@@ -0,0 +1,67 @@
+export interface CloudinaryTransformOptions {
+  width?: number;
+  height?: number;
+  crop?: 'limit' | 'fill' | 'fit' | 'scale' | 'thumb' | 'crop';
+  quality?: number | 'auto';
+  format?: 'auto' | 'webp' | 'jpg' | 'png';
+  gravity?: 'auto' | 'face' | 'center';
+}
+
+/**
+ * Добавляет трансформации Cloudinary к URL изображения
+ * @param url Оригинальный URL от Cloudinary
+ * @param options Параметры трансформации
+ * @returns URL с трансформациями
+ */
+export function transformCloudinaryUrl(
+  url: string | undefined | null,
+  options: CloudinaryTransformOptions
+): string {
+  if (!url || !url.includes('cloudinary.com')) {
+    return url || ''; // Возвращаем оригинальный URL если это не Cloudinary
+  }
+
+  const transformations: string[] = [];
+
+  if (options.width) {
+    transformations.push(`w_${options.width}`);
+  }
+  if (options.height) {
+    transformations.push(`h_${options.height}`);
+  }
+  if (options.crop) {
+    transformations.push(`c_${options.crop}`);
+  } else if (options.width || options.height) {
+    // По умолчанию используем limit если указаны размеры
+    transformations.push('c_limit');
+  }
+  if (options.quality) {
+    transformations.push(`q_${options.quality}`);
+  } else {
+    // Автоматическое качество по умолчанию
+    transformations.push('q_auto');
+  }
+  if (options.format) {
+    transformations.push(`f_${options.format}`);
+  } else {
+    // Автоматический формат по умолчанию
+    transformations.push('f_auto');
+  }
+  if (options.gravity) {
+    transformations.push(`g_${options.gravity}`);
+  }
+
+  if (transformations.length === 0) {
+    return url;
+  }
+
+  const transformString = transformations.join(',');
+
+  // Вставляем трансформации между /upload/ и версией/путем
+  // Формат: https://res.cloudinary.com/{cloud}/image/upload/{transformations}/{version}/{path}
+  return url.replace(
+    /\/upload\/(v\d+\/)?/,
+    `/upload/${transformString}/$1`
+  );
+}
+

package/src/shared/utils/cn.ts

@@ -0,0 +1,7 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+