@rynt/sdk 0.9.53

package/src/shared/utils/updater.ts

@@ -0,0 +1,218 @@
+import axios from 'axios';
+import {
+  getPlatform,
+  getArchitecture,
+  getPackageNwPath,
+  getExecutablePath,
+} from './platform';
+
+// Проверка на наличие Node.js окружения (NW.js)
+const isNodeEnv = typeof window !== 'undefined' && (window as any).nw;
+
+let fs: any;
+let path: any;
+let child_process: any;
+let os: any;
+let AdmZip: any;
+
+if (isNodeEnv) {
+  try {
+    const nw = (window as any).nw;
+    fs = nw.require('fs');
+    path = nw.require('path');
+    child_process = nw.require('child_process');
+    os = nw.require('os');
+    AdmZip = nw.require('adm-zip');
+  } catch (error) {
+    console.error('Не удалось загрузить Node.js модули:', error);
+  }
+}
+
+const VERSION_URL = 'http://repo.rynt.space/version';
+const REPO_BASE_URL = 'https://repo.rynt.space/latest';
+
+/**
+ * Получить текущую версию приложения
+ */
+export function getCurrentVersion(): string {
+  // Версия из package.json через Vite
+  return import.meta.env.VITE_PACKAGE_VERSION || '0.0.0';
+}
+
+/**
+ * Проверить, находимся ли мы в dev режиме
+ */
+export function isDevMode(): boolean {
+  console.log(import.meta.env.VITE_PACKAGE_VERSION, import.meta.env.DEV);
+  return import.meta.env.DEV === true;
+}
+
+/**
+ * Получить актуальную версию с сервера
+ */
+export async function getLatestVersion(): Promise<string> {
+  try {
+    const response = await axios.get(VERSION_URL + '?' + Date.now(), {
+      timeout: 10000,
+    });
+    return response.data.trim();
+  } catch (error) {
+    console.error('Ошибка при получении версии с сервера:', error);
+    throw error;
+  }
+}
+
+/**
+ * Скачать новый package.nw
+ */
+export async function downloadUpdate(
+  onProgress?: (progress: number) => void,
+): Promise<void> {
+  if (!isNodeEnv || !fs || !path || !AdmZip) {
+    throw new Error('Node.js окружение недоступно');
+  }
+
+  const platform = getPlatform();
+  const arch = getArchitecture();
+  const downloadUrl = `${REPO_BASE_URL}/${platform}/packages/${platform}-${arch}.nw`;
+
+  console.log(`[Updater] Скачивание обновления с ${downloadUrl}`);
+
+  const execDir = getExecutablePath();
+  const downloadDir = execDir || process.cwd();
+
+  const tempFilePath = path.join(downloadDir, 'package.nw.new');
+  const extractTargetDir = process.cwd();
+
+  try {
+    // Загружаем FileDownloader через nw.require
+    const nw = (window as any).nw;
+    const FileDownloader = nw.require('nodejs-file-downloader');
+
+    // Скачиваем файл во временный файл
+    const downloader = new FileDownloader({
+      url: downloadUrl,
+      directory: downloadDir,
+      fileName: 'package.nw.new',
+      onProgress: (percentage: string | number) => {
+        const progress =
+          typeof percentage === 'string' ? parseFloat(percentage) : percentage;
+        if (onProgress) {
+          onProgress(progress);
+        }
+      },
+    });
+
+    await downloader.download();
+    console.log('[Updater] Файл успешно скачан');
+
+    // Проверяем, что файл существует
+    if (!fs.existsSync(tempFilePath)) {
+      throw new Error('Скачанный файл не найден');
+    }
+
+    console.log(
+      `[Updater] Распаковка обновления в ${extractTargetDir} (overwrite без очистки)`,
+    );
+    extractArchiveWithOverwrite(tempFilePath, extractTargetDir);
+
+    // Постоянное обновление: package.nw рядом с exe (переживает полный перезапуск).
+    const packageNwPath = getPackageNwPath();
+    if (packageNwPath && downloadDir) {
+      if (fs.existsSync(packageNwPath)) {
+        console.log('[Updater] Удаление старого package.nw');
+        fs.unlinkSync(packageNwPath);
+      }
+      console.log('[Updater] Сохранение нового package.nw рядом с исполняемым файлом');
+      fs.renameSync(tempFilePath, packageNwPath);
+    } else if (fs.existsSync(tempFilePath)) {
+      fs.unlinkSync(tempFilePath);
+    }
+
+    console.log('[Updater] Обновление успешно установлено');
+  } catch (error) {
+    if (fs.existsSync(tempFilePath)) {
+      try {
+        fs.unlinkSync(tempFilePath);
+      } catch (e) {
+        console.error('[Updater] Ошибка при удалении временного файла:', e);
+      }
+    }
+    throw error;
+  }
+}
+
+function extractArchiveWithOverwrite(
+  archivePath: string,
+  targetDir: string,
+): void {
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  const zip = new AdmZip(archivePath);
+  zip.extractAllTo(targetDir, true);
+}
+
+/**
+ * Перезапустить приложение
+ */
+export function restartApplication(): void {
+  if (!isNodeEnv || !child_process || !path || !os) {
+    throw new Error('Node.js окружение недоступно');
+  }
+
+  const execPath = process.execPath;
+  const execDir = path.dirname(execPath);
+  const platform = os.platform();
+
+  console.log('[Updater] Перезапуск приложения...');
+
+  // Создаем скрипт для перезапуска
+  let restartScript: string;
+  let restartCommand: string;
+
+  if (platform === 'win32') {
+    // Windows: создаем bat-файл
+    restartScript = path.join(execDir, 'restart.bat');
+    const batContent = `@echo off
+timeout /t 1 /nobreak >nul
+start "" "${execPath}"
+`;
+    fs.writeFileSync(restartScript, batContent);
+    restartCommand = restartScript;
+  } else if (platform === 'darwin') {
+    // macOS: создаем shell-скрипт
+    restartScript = path.join(execDir, 'restart.sh');
+    const shContent = `#!/bin/bash
+sleep 3
+open "${execPath}"
+`;
+    fs.writeFileSync(restartScript, shContent);
+    fs.chmodSync(restartScript, '755');
+    restartCommand = restartScript;
+  } else {
+    // Linux: создаем shell-скрипт
+    restartScript = path.join(execDir, 'restart.sh');
+    const shContent = `#!/bin/bash
+sleep 3
+"${execPath}" &
+`;
+    fs.writeFileSync(restartScript, shContent);
+    fs.chmodSync(restartScript, '755');
+    restartCommand = restartScript;
+  }
+
+  // Запускаем скрипт перезапуска в отдельном процессе
+  const restartProcess = child_process.spawn(restartCommand, [], {
+    detached: true,
+    stdio: 'ignore',
+    shell: platform === 'win32',
+  });
+
+  restartProcess.unref();
+
+  // Закрываем текущее приложение
+  if ((window as any).nw) {
+    (window as any).nw.App.quit();
+  }
+}

package/src/shared/utils/uploadImage.ts

@@ -0,0 +1,195 @@
+interface UploadImageOptions {
+  folder?: string;
+  maxWidth?: number;
+  maxHeight?: number;
+  quality?: number;
+  /** Максимальный размер файла в байтах (по умолчанию 5 MB). */
+  maxSizeBytes?: number;
+}
+
+interface UploadImageResult {
+  url: string;
+  width: number;
+  height: number;
+  size: number;
+  originalName?: string;
+  mimeType?: string;
+}
+
+function compressImage(
+  file: File,
+  maxWidth: number,
+  maxHeight: number,
+  quality: number = 0.85
+): Promise<Blob> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      const img = new Image();
+      img.onload = () => {
+        let width = img.width;
+        let height = img.height;
+
+        if (width > maxWidth || height > maxHeight) {
+          const ratio = Math.min(maxWidth / width, maxHeight / height);
+          width = Math.round(width * ratio);
+          height = Math.round(height * ratio);
+        }
+
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+
+        if (!ctx) {
+          reject(new Error('Не удалось создать canvas context'));
+          return;
+        }
+
+        ctx.drawImage(img, 0, 0, width, height);
+
+        canvas.toBlob(
+          (blob) => {
+            if (blob) {
+              resolve(blob);
+            } else {
+              reject(new Error('Не удалось сжать изображение'));
+            }
+          },
+          file.type.startsWith('image/png') ? 'image/png' : 'image/jpeg',
+          quality
+        );
+      };
+      img.onerror = () => reject(new Error('Ошибка загрузки изображения'));
+      img.src = e.target?.result as string;
+    };
+    reader.onerror = () => reject(new Error('Ошибка чтения файла'));
+    reader.readAsDataURL(file);
+  });
+}
+
+function getImageDimensions(file: File): Promise<{ width: number; height: number }> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = (e) => {
+      const img = new Image();
+      img.onload = () => {
+        resolve({ width: img.width, height: img.height });
+      };
+      img.onerror = () => reject(new Error('Ошибка загрузки изображения'));
+      img.src = e.target?.result as string;
+    };
+    reader.onerror = () => reject(new Error('Ошибка чтения файла'));
+    reader.readAsDataURL(file);
+  });
+}
+
+async function uploadToCloudinary(
+  blob: Blob,
+  options: UploadImageOptions = {}
+): Promise<UploadImageResult> {
+  const CLOUDINARY_URL = (import.meta as any).env?.VITE_CLOUDINARY_URL as string | undefined;
+  const CLOUDINARY_CLOUD_NAME = (import.meta as any).env?.VITE_CLOUDINARY_CLOUD_NAME as string | undefined;
+  const CLOUDINARY_UPLOAD_PRESET = (import.meta as any).env?.VITE_CLOUDINARY_UPLOAD_PRESET as string | undefined;
+
+  const parseCloudinaryUrl = (url: string): string | null => {
+    try {
+      const match = url.match(/cloudinary:\/\/[^:]+:[^@]+@(.+)/);
+      return match ? match[1] : null;
+    } catch {
+      return null;
+    }
+  };
+
+  const cloudName = CLOUDINARY_CLOUD_NAME || (CLOUDINARY_URL ? parseCloudinaryUrl(CLOUDINARY_URL) : null);
+
+  if (!cloudName) {
+    throw new Error('Cloudinary Cloud Name не настроен. Установите VITE_CLOUDINARY_CLOUD_NAME или VITE_CLOUDINARY_URL');
+  }
+
+  if (!CLOUDINARY_UPLOAD_PRESET) {
+    throw new Error('Cloudinary Upload Preset не настроен. Установите VITE_CLOUDINARY_UPLOAD_PRESET');
+  }
+
+  const formData = new FormData();
+  formData.append('file', blob);
+  formData.append('upload_preset', CLOUDINARY_UPLOAD_PRESET);
+
+  if (options.folder) {
+    formData.append('folder', options.folder);
+  }
+
+  const response = await fetch(
+    `https://api.cloudinary.com/v1_1/${cloudName}/image/upload`,
+    {
+      method: 'POST',
+      body: formData,
+    }
+  );
+
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => ({}));
+    throw new Error(errorData?.error?.message || `Ошибка загрузки: ${response.statusText}`);
+  }
+
+  const data = await response.json();
+  const url = data.secure_url || data.url;
+
+  if (!url) {
+    throw new Error('Не удалось получить ссылку на изображение');
+  }
+
+  return {
+    url,
+    width: data.width || 0,
+    height: data.height || 0,
+    size: data.bytes || blob.size,
+    mimeType: data.format ? `image/${data.format}` : undefined,
+  };
+}
+
+export async function uploadImage(
+  file: File,
+  options: UploadImageOptions = {}
+): Promise<UploadImageResult> {
+  const maxWidth = options.maxWidth || 1280;
+  const maxHeight = options.maxHeight || 1280;
+  const quality = options.quality || 0.85;
+
+  if (!file.type.startsWith('image/')) {
+    throw new Error('Файл должен быть изображением');
+  }
+
+  const maxSizeBytes = options.maxSizeBytes ?? 5 * 1024 * 1024;
+  if (file.size > maxSizeBytes) {
+    throw new Error(
+      `Размер файла не должен превышать ${Math.round(maxSizeBytes / (1024 * 1024))}MB`,
+    );
+  }
+
+  const originalDimensions = await getImageDimensions(file);
+
+  const isGif = file.type === 'image/gif';
+  let blobToUpload: Blob;
+  let finalWidth = originalDimensions.width;
+  let finalHeight = originalDimensions.height;
+
+  if (isGif) {
+    blobToUpload = file;
+  } else {
+    blobToUpload = await compressImage(file, maxWidth, maxHeight, quality);
+    const compressedDimensions = await getImageDimensions(new File([blobToUpload], file.name, { type: blobToUpload.type }));
+    finalWidth = compressedDimensions.width;
+    finalHeight = compressedDimensions.height;
+  }
+
+  const result = await uploadToCloudinary(blobToUpload, options);
+
+  return {
+    ...result,
+    width: result.width || finalWidth,
+    height: result.height || finalHeight,
+    originalName: file.name,
+    mimeType: file.type,
+  };
+}

package/src/shared/utils/user-status.ts

@@ -0,0 +1,9 @@
+import type { UserStatusDetail } from '../types/user';
+
+/** Друг или пользователь публикует локальный мир («Для друзей»). */
+export function isSharingLocalGame(
+  statusDetail: UserStatusDetail | null | undefined,
+): boolean {
+  if (!statusDetail || statusDetail.type !== 'build') return false;
+  return Boolean(statusDetail.shareForFriends && statusDetail.localServer);
+}

package/src/tiptap/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Типы и API ядра TipTap для авторов расширений (dev).
+ * Регистрируйте в редактор объекты из своих `@tiptap/extension-*` (они в бандле расширения).
+ * Ядро `@tiptap/core` при сборке расширения подменяется host-shim — тот же инстанс, что у MarkdownEditor.
+ */
+export type { AnyExtension, Editor, Extension, Mark, Node } from '@tiptap/core';
+export { Extension } from '@tiptap/core';

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@vue/tsconfig/tsconfig.dom.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "composite": false,
+    "types": ["node"],
+    "skipLibCheck": true
+  },
+  "include": ["env.d.ts", "host-shims.d.ts", "src/**/*.ts", "src/**/*.vue"],
+  "vueCompilerOptions": {
+    "strictTemplates": false
+  }
+}