@rynt/sdk 0.9.53

package/src/shared/utils/skin-render-cache.ts

@@ -0,0 +1,372 @@
+/**
+ * Утилиты для работы с кешем рендеров скинов Minecraft
+ */
+
+import axios from 'axios';
+
+import { getAppDataPath } from './app-paths';
+
+/** Параметры 3D-рендера (совместимы с пакетом `@rynt/minecraft-skin-renderer`). */
+export interface SkinRender3DOptions {
+  zoom?: number;
+  slim?: boolean;
+  rotationY?: number;
+  rotationX?: number;
+}
+
+export type SkinRender3DFn = (
+  source: string | Buffer,
+  options?: SkinRender3DOptions,
+) => Promise<Blob>;
+
+let skinRenderImpl: SkinRender3DFn | null = null;
+
+/**
+ * Подключение реализации рендера из хост-приложения (`@rynt/minecraft-skin-renderer`).
+ * SDK сам не зависит от пакета рендера.
+ */
+export function configureRyntSkinRenderer(fn: SkinRender3DFn): void {
+  skinRenderImpl = fn;
+}
+
+async function invokeSkinRender(
+  renderSource: string | Buffer,
+  options?: SkinRender3DOptions,
+): Promise<Blob> {
+  if (!skinRenderImpl) {
+    throw new Error(
+      'Skin renderer not configured: call configureRyntSkinRenderer() from the host.',
+    );
+  }
+  return skinRenderImpl(renderSource, options);
+}
+
+/**
+ * Получить SHA1 хеш от URL скина или локального файла
+ */
+export async function getSkinSha1(skinUrl: string): Promise<string> {
+  // Проверяем, что мы в NW.js окружении
+  if (typeof window === 'undefined' || !(window as any).nw) {
+    throw new Error('Skin operations are only available in NW.js environment');
+  }
+
+  const nw = (window as any).nw;
+  const crypto = nw.require('crypto');
+  const Buffer = nw.require('buffer').Buffer;
+  const fs = nw.require('fs');
+  const path = nw.require('path');
+
+  let skinBuffer: Buffer;
+
+  // Проверяем, является ли URL локальным файлом
+  const isHttpUrl =
+    skinUrl.startsWith('http://') || skinUrl.startsWith('https://');
+  const isFileUrl = skinUrl.startsWith('file://');
+  const isRelativePath = skinUrl.startsWith('./') || skinUrl.startsWith('/');
+
+  if (isHttpUrl) {
+    // Скачиваем скин через HTTP
+    const response = await axios.get(skinUrl, {
+      responseType: 'arraybuffer',
+    });
+    skinBuffer = Buffer.from(response.data);
+  } else if (isFileUrl || isRelativePath) {
+    // Читаем локальный файл
+    let filePath: string;
+    if (isFileUrl) {
+      // Преобразуем file:// URL в путь
+      filePath = skinUrl.replace(/^file:\/\//, '').replace(/^\//, '');
+      // В Windows убираем лишний слеш после file:///
+      if (process.platform === 'win32' && filePath.match(/^[A-Za-z]:/)) {
+        // Уже правильный путь
+      } else {
+        filePath = filePath.replace(/^\//, '');
+      }
+    } else {
+      // Относительный путь - разрешаем относительно public директории
+      // В NW.js public директория может быть в process.cwd() или в process.cwd()/public
+      const cwd = process.cwd();
+      const relativePath = skinUrl.replace(/^\.\//, '');
+
+      // Пробуем несколько вариантов пути
+      const possiblePaths = [
+        path.join(cwd, relativePath), // Если cwd уже в public
+        path.join(cwd, 'public', relativePath), // Если cwd в packages/client
+        path.resolve(cwd, 'public', relativePath), // Абсолютный путь
+      ];
+
+      // Проверяем, какой путь существует
+      let foundPath: string | null = null;
+      for (const possiblePath of possiblePaths) {
+        try {
+          if (fs.existsSync(possiblePath)) {
+            foundPath = possiblePath;
+            break;
+          }
+        } catch {
+          // Игнорируем ошибки проверки
+        }
+      }
+
+      if (foundPath) {
+        filePath = foundPath;
+      } else {
+        // Если ни один путь не найден, используем первый вариант
+        filePath = path.join(cwd, 'public', relativePath);
+      }
+    }
+
+    // Читаем файл синхронно
+    skinBuffer = fs.readFileSync(filePath);
+  } else {
+    throw new Error(`Invalid skin URL: ${skinUrl}`);
+  }
+
+  // Вычисляем SHA1
+  const hash = crypto.createHash('sha1');
+  hash.update(skinBuffer);
+  return hash.digest('hex');
+}
+
+/**
+ * Получить путь к файлу рендера в кеше
+ */
+export function getRenderCachePath(sha1: string): string {
+  if (typeof window === 'undefined' || !(window as any).nw) {
+    throw new Error('File operations are only available in NW.js environment');
+  }
+
+  const nw = (window as any).nw;
+  const path = nw.require('path');
+
+  const firstTwoChars = sha1.substring(0, 2);
+  const cacheDir = path.join(
+    getAppDataPath(),
+    'assets',
+    'skin-renders',
+    firstTwoChars,
+  );
+  const renderPath = path.join(cacheDir, `${sha1}.png`);
+
+  return renderPath;
+}
+
+/**
+ * Проверить, существует ли рендер в кеше
+ */
+export async function isRenderCached(sha1: string): Promise<boolean> {
+  if (typeof window === 'undefined' || !(window as any).nw) {
+    return false;
+  }
+
+  const nw = (window as any).nw;
+  const fs = nw.require('fs');
+
+  const renderPath = getRenderCachePath(sha1);
+
+  return new Promise((resolve) => {
+    fs.access(renderPath, fs.constants.F_OK, (err: Error | null) => {
+      resolve(!err);
+    });
+  });
+}
+
+/**
+ * Получить путь к рендеру из кеша (file:// URL для использования в img src)
+ */
+export function getRenderCacheUrl(sha1: string): string {
+  const renderPath = getRenderCachePath(sha1);
+  // Преобразуем путь в file:// URL
+  const normalizedPath = renderPath.replace(/\\/g, '/');
+  // В Windows пути начинаются с буквы диска (C:/), в Unix - с /
+  if (normalizedPath.match(/^[A-Za-z]:/)) {
+    // Windows путь
+    return `file:///${normalizedPath}`;
+  }
+  // Unix путь
+  return `file://${normalizedPath}`;
+}
+
+/**
+ * Рендерить скин и сохранить в кеш
+ */
+export async function renderAndCacheSkin(
+  skinUrl: string,
+  sha1: string,
+  options?: {
+    zoom?: number;
+    slim?: boolean;
+    rotationY?: number;
+    rotationX?: number;
+  },
+): Promise<string> {
+  if (typeof window === 'undefined' || !(window as any).nw) {
+    throw new Error('Skin rendering is only available in NW.js environment');
+  }
+
+  const nw = (window as any).nw;
+  const fs = nw.require('fs');
+  const path = nw.require('path');
+
+  // Определяем тип источника
+  const isHttpUrl =
+    skinUrl.startsWith('http://') || skinUrl.startsWith('https://');
+  const isFileUrl = skinUrl.startsWith('file://');
+
+  // Для локальных файлов читаем их в Buffer, чтобы создать Blob URL (file:// не работает в браузере)
+  let renderSource: string | Buffer;
+  if (!isHttpUrl) {
+    // Локальный файл - читаем в Buffer
+    let filePath: string;
+    if (isFileUrl) {
+      // Преобразуем file:// URL в путь
+      filePath = skinUrl.replace(/^file:\/\//, '').replace(/^\//, '');
+      // В Windows убираем лишний слеш после file:///
+      if (process.platform === 'win32' && filePath.match(/^[A-Za-z]:/)) {
+        // Уже правильный путь
+      } else {
+        filePath = filePath.replace(/^\//, '');
+      }
+    } else {
+      // Относительный путь - разрешаем относительно public директории
+      // В NW.js public директория может быть в process.cwd() или в process.cwd()/public
+      const cwd = process.cwd();
+      const relativePath = skinUrl.replace(/^\.\//, '');
+
+      // Пробуем несколько вариантов пути
+      const possiblePaths = [
+        path.join(cwd, relativePath), // Если cwd уже в public
+        path.join(cwd, 'public', relativePath), // Если cwd в packages/client
+        path.resolve(cwd, 'public', relativePath), // Абсолютный путь
+      ];
+
+      // Проверяем, какой путь существует
+      let foundPath: string | null = null;
+      for (const possiblePath of possiblePaths) {
+        try {
+          if (fs.existsSync(possiblePath)) {
+            foundPath = possiblePath;
+            break;
+          }
+        } catch {
+          // Игнорируем ошибки проверки
+        }
+      }
+
+      if (foundPath) {
+        filePath = foundPath;
+      } else {
+        // Если ни один путь не найден, используем первый вариант
+        filePath = path.join(cwd, 'public', relativePath);
+      }
+    }
+
+    // Читаем файл в Buffer
+    renderSource = fs.readFileSync(filePath);
+  } else {
+    // HTTP URL - передаем как есть
+    renderSource = skinUrl;
+  }
+
+  // Рендерим скин (теперь возвращает Blob)
+  let renderBlob: Blob;
+  try {
+    renderBlob = await invokeSkinRender(renderSource, {
+      zoom: options?.zoom ?? 1.0,
+      slim: options?.slim ?? false,
+      rotationY: options?.rotationY ?? 45, // Изометрический вид сбоку
+      rotationX: options?.rotationX ?? 30, // Наклон сверху для изометрии
+    });
+  } catch (error) {
+    console.error('[Skin Render Cache] Error during invokeSkinRender:', error);
+    throw error;
+  }
+
+  // Конвертируем Blob в Buffer для сохранения
+  const arrayBuffer = await renderBlob.arrayBuffer();
+  const renderBuffer = Buffer.from(arrayBuffer);
+
+  // Создаем директорию для кеша, если её нет
+  const renderPath = getRenderCachePath(sha1);
+  const cacheDir = path.dirname(renderPath);
+
+  // Создаем директорию рекурсивно
+  await new Promise<void>((resolve, reject) => {
+    // Проверяем, существует ли директория
+    fs.stat(cacheDir, (err: Error | null) => {
+      if (err) {
+        // Директория не существует, создаем её
+        fs.mkdir(cacheDir, { recursive: true }, (mkdirErr: Error | null) => {
+          if (mkdirErr) {
+            reject(mkdirErr);
+          } else {
+            resolve();
+          }
+        });
+      } else {
+        resolve();
+      }
+    });
+  });
+
+  // Сохраняем рендер
+  await new Promise<void>((resolve, reject) => {
+    fs.writeFile(renderPath, renderBuffer, (err: Error | null) => {
+      if (err) {
+        console.error('[Skin Render Cache] Error saving render:', err);
+        reject(err);
+      } else {
+        // Проверяем, что файл действительно создан
+        fs.stat(renderPath, (statErr: Error | null) => {
+          if (statErr) {
+            console.error(
+              '[Skin Render Cache] Error verifying saved file:',
+              statErr,
+            );
+            reject(statErr);
+          } else {
+            resolve();
+          }
+        });
+      }
+    });
+  });
+
+  return getRenderCacheUrl(sha1);
+}
+
+/**
+ * Получить рендер скина (с кешированием)
+ * Возвращает file:// URL для использования в img src
+ */
+export async function getSkinRender(
+  skinUrl: string,
+  sha1?: string,
+  options?: {
+    zoom?: number;
+    slim?: boolean;
+    rotationY?: number;
+    rotationX?: number;
+  },
+): Promise<string> {
+  try {
+    // Если sha1 не передан, вычисляем его
+    let skinSha1 = sha1;
+    if (!skinSha1) {
+      skinSha1 = await getSkinSha1(skinUrl);
+    }
+
+    // Проверяем кеш
+    const isCached = await isRenderCached(skinSha1);
+    if (isCached) {
+      return getRenderCacheUrl(skinSha1);
+    }
+
+    // Рендерим и кешируем
+    const renderUrl = await renderAndCacheSkin(skinUrl, skinSha1, options);
+    return renderUrl;
+  } catch (error) {
+    console.error('[Skin Render] Error during rendering:', error);
+    throw error;
+  }
+}

package/src/shared/utils/stripMarkdown.ts

@@ -0,0 +1,45 @@
+/**
+ * Удаляет markdown форматирование из текста
+ */
+export function stripMarkdown(text: string): string {
+  if (!text) return '';
+
+  const withoutHtml = text
+    // Удаляем HTML-теги (для нового формата описаний)
+    .replace(/<[^>]*>/g, ' ')
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>');
+
+  return withoutHtml
+    // Удаляем заголовки
+    .replace(/^#{1,6}\s+/gm, '')
+    // Удаляем жирный текст
+    .replace(/\*\*([^*]+)\*\*/g, '$1')
+    .replace(/__([^_]+)__/g, '$1')
+    // Удаляем курсив
+    .replace(/\*([^*]+)\*/g, '$1')
+    .replace(/_([^_]+)_/g, '$1')
+    // Удаляем зачеркнутый текст
+    .replace(/~~([^~]+)~~/g, '$1')
+    // Удаляем код
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/```[\s\S]*?```/g, '')
+    // Удаляем ссылки
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    // Удаляем изображения
+    .replace(/!\[([^\]]*)\]\([^)]+\)/g, '')
+    // Удаляем списки
+    .replace(/^[\s]*[-*+]\s+/gm, '')
+    .replace(/^[\s]*\d+\.\s+/gm, '')
+    // Удаляем цитаты
+    .replace(/^>\s+/gm, '')
+    // Удаляем горизонтальные линии
+    .replace(/^[-*]{3,}$/gm, '')
+    // Убираем лишние пробелы
+    .replace(/[ \t]{2,}/g, ' ')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+

package/src/shared/utils/transliterate.ts

@@ -0,0 +1,74 @@
+/**
+ * Транслитерация кириллицы в латиницу для генерации ID из имени
+ */
+const transliterationMap: Record<string, string> = {
+  а: 'a',
+  б: 'b',
+  в: 'v',
+  г: 'g',
+  д: 'd',
+  е: 'e',
+  ё: 'e',
+  ж: 'zh',
+  з: 'z',
+  и: 'i',
+  й: 'y',
+  к: 'k',
+  л: 'l',
+  м: 'm',
+  н: 'n',
+  о: 'o',
+  п: 'p',
+  р: 'r',
+  с: 's',
+  т: 't',
+  у: 'u',
+  ф: 'f',
+  х: 'h',
+  ц: 'ts',
+  ч: 'ch',
+  ш: 'sh',
+  щ: 'shch',
+  ъ: '',
+  ы: 'y',
+  ь: '',
+  э: 'e',
+  ю: 'yu',
+  я: 'ya',
+};
+
+/**
+ * Генерирует ID из имени сборки через транслитерацию
+ * Пробелы заменяются на дефисы, все приводится к lowercase
+ */
+export function generateBuildId(name: string): string {
+  if (!name) return '';
+
+  let result = name
+    .toLowerCase()
+    .split('')
+    .map((char) => {
+      // Если это кириллица, транслитерируем
+      if (transliterationMap[char]) {
+        return transliterationMap[char];
+      }
+      // Если это латиница или цифра, оставляем как есть
+      if (/[a-z0-9]/.test(char)) {
+        return char;
+      }
+      // Пробелы и другие символы заменяем на дефис
+      if (/\s/.test(char)) {
+        return '-';
+      }
+      // Остальные символы удаляем
+      return '';
+    })
+    .join('')
+    // Убираем множественные дефисы
+    .replace(/-+/g, '-')
+    // Убираем дефисы в начале и конце
+    .replace(/^-+|-+$/g, '');
+
+  return result || 'build';
+}
+

package/src/shared/utils/updateAccountSkinRender.ts

@@ -0,0 +1,64 @@
+/**
+ * Утилита для обновления рендера скина аккаунта
+ */
+
+import type { Account } from '@/models/accounts/types';
+import { getSkinSha1 } from './skin-render-cache';
+
+/**
+ * Обновить рендер скина для одного аккаунта
+ * Получает URL скина от провайдера, вычисляет SHA1 и обновляет профиль аккаунта
+ * 
+ * @param account - Аккаунт для обновления
+ * @param provider - Провайдер аккаунта
+ * @param defaultSkinUrl - URL дефолтного скина, если у аккаунта нет скина
+ * @returns Обновленный профиль с skinUrl и skinSha1, или null если обновление не требуется
+ */
+export async function updateAccountSkinRender(
+  account: Account,
+  provider: { getSkinUrl?: (account: Account) => Promise<string | null> | string | null; getProfile?: (account: Account) => Promise<any> },
+  defaultSkinUrl: string = './assets/image/steve_skin.png'
+): Promise<{ skinUrl: string; skinSha1: string | null } | null> {
+  try {
+    // Получаем скин от провайдера
+    let skinUrl: string | null = null;
+    if (provider.getSkinUrl) {
+      skinUrl = await provider.getSkinUrl(account);
+    } else if (provider.getProfile) {
+      const updatedProfile = await provider.getProfile(account);
+      skinUrl = updatedProfile.skinUrl || null;
+    }
+
+    // Если нет скина, подставляем дефолтный
+    if (!skinUrl) {
+      skinUrl = defaultSkinUrl;
+    }
+
+    // Вычисляем SHA1 скина, если он изменился
+    let skinSha1: string | null = null;
+    if (skinUrl !== account.profile?.skinUrl) {
+      try {
+        skinSha1 = await getSkinSha1(skinUrl);
+      } catch (error) {
+        console.debug('Failed to get skin SHA1:', error);
+      }
+    } else {
+      // Если URL не изменился, используем существующий SHA1
+      skinSha1 = account.profile?.skinSha1 || null;
+    }
+
+    // Возвращаем обновленные данные, если они изменились
+    if (skinUrl !== account.profile?.skinUrl || skinSha1 !== account.profile?.skinSha1) {
+      return {
+        skinUrl,
+        skinSha1,
+      };
+    }
+
+    return null;
+  } catch (error) {
+    console.debug(`Failed to update skin render for account ${account.id}:`, error);
+    return null;
+  }
+}
+