@rynt/sdk 0.9.53

package/src/shared/utils/rich-content.ts

@@ -0,0 +1,294 @@
+import { marked } from 'marked';
+
+marked.setOptions({
+  breaks: true,
+  gfm: true,
+});
+
+const looksLikeHtml = (content: string): boolean => /<[a-z][\s\S]*>/i.test(content);
+
+const sanitizeBasicHtml = (html: string): string => {
+  return html
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+    .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
+    .replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, '')
+    .replace(/<embed\b[^<]*(?:(?!<\/embed>)<[^<]*)*<\/embed>/gi, '')
+    .replace(/\son\w+="[^"]*"/gi, '')
+    .replace(/\son\w+='[^']*'/gi, '');
+};
+
+const linkifyTextInNode = (root: HTMLElement) => {
+  const urlRegex = /https?:\/\/[^\s<]+[^\s<.,:;"')\]}]/gi;
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const textNodes: Text[] = [];
+
+  let current = walker.nextNode();
+  while (current) {
+    const textNode = current as Text;
+    const parentTag = textNode.parentElement?.tagName;
+    if (!parentTag || ['A', 'CODE', 'PRE', 'SCRIPT', 'STYLE'].includes(parentTag)) {
+      current = walker.nextNode();
+      continue;
+    }
+    if (urlRegex.test(textNode.data)) {
+      textNodes.push(textNode);
+    }
+    urlRegex.lastIndex = 0;
+    current = walker.nextNode();
+  }
+
+  textNodes.forEach((textNode) => {
+    const text = textNode.data;
+    const fragment = document.createDocumentFragment();
+    let lastIndex = 0;
+
+    text.replace(urlRegex, (url, offset: number) => {
+      if (offset > lastIndex) {
+        fragment.appendChild(document.createTextNode(text.slice(lastIndex, offset)));
+      }
+
+      const link = document.createElement('a');
+      link.href = url;
+      link.textContent = url;
+      link.target = '_blank';
+      link.rel = 'noopener noreferrer';
+      fragment.appendChild(link);
+
+      lastIndex = offset + url.length;
+      return url;
+    });
+
+    if (lastIndex < text.length) {
+      fragment.appendChild(document.createTextNode(text.slice(lastIndex)));
+    }
+
+    textNode.parentNode?.replaceChild(fragment, textNode);
+  });
+};
+
+const setExternalLinksBlank = (html: string): string => {
+  if (typeof window === 'undefined' || typeof DOMParser === 'undefined') {
+    return html.replace(
+      /<a\b([^>]*?)href=(["'])(https?:\/\/[^"']+)\2([^>]*)>/gi,
+      '<a$1href=$2$3$2$4 target="_blank" rel="noopener noreferrer">',
+    );
+  }
+
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, 'text/html');
+  const root = doc.body.firstElementChild as HTMLElement | null;
+  if (!root) return html;
+
+  linkifyTextInNode(root);
+
+  const links = root.querySelectorAll('a[href]');
+  links.forEach((link) => {
+    const href = link.getAttribute('href') || '';
+    if (/^https?:\/\//i.test(href)) {
+      link.setAttribute('target', '_blank');
+      link.setAttribute('rel', 'noopener noreferrer');
+    }
+  });
+
+  return root.innerHTML;
+};
+
+const escapeHtmlAttr = (value: string): string =>
+  value
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/</g, '&lt;');
+
+const parseContentToHtml = (content: string): string => {
+  if (!content) return '';
+  if (looksLikeHtml(content)) return content;
+  return marked.parse(content) as string;
+};
+
+/**
+ * Переносит все изображения в конец HTML для редактора.
+ */
+export const normalizeEditorHtmlContent = (content: string): string => {
+  const { html, images } = splitRichContentImages(content);
+  if (!images.length) return html;
+
+  const imageHtml = images
+    .map((image) => {
+      const alt = image.alt ? ` alt="${escapeHtmlAttr(image.alt)}"` : '';
+      return `<img class="md-editor-image" src="${escapeHtmlAttr(image.src)}"${alt} />`;
+    })
+    .join('');
+
+  if (!html) return imageHtml;
+  return `${html}${imageHtml}`;
+};
+
+/**
+ * Конвертирует сохраненный контент в HTML для редактора без переноса картинок.
+ */
+export const toEditorHtmlContent = (content: string): string => {
+  if (!content) return '';
+  return sanitizeBasicHtml(parseContentToHtml(content));
+};
+
+/**
+ * Конвертирует сохраненный контент в HTML для редактора (legacy: картинки в конец).
+ */
+export const toHtmlContent = (content: string): string => {
+  return normalizeEditorHtmlContent(content);
+};
+
+export interface RichContentImage {
+  src: string;
+  alt: string;
+}
+
+const parseHtmlRoot = (html: string): HTMLElement | null => {
+  if (typeof window === 'undefined' || typeof DOMParser === 'undefined') {
+    return null;
+  }
+
+  const doc = new DOMParser().parseFromString(`<div>${html}</div>`, 'text/html');
+  return doc.body.firstElementChild as HTMLElement | null;
+};
+
+/**
+ * Извлекает изображения из HTML и возвращает текст без них.
+ * Изображения всегда собираются в конец списка, даже если в исходнике были inline.
+ */
+export const splitRichContentImages = (
+  content: string,
+): { html: string; images: RichContentImage[] } => {
+  const html = sanitizeBasicHtml(parseContentToHtml(content));
+  const root = parseHtmlRoot(html);
+
+  if (!root) {
+    const images: RichContentImage[] = [];
+    const withoutImages = html.replace(/<img\b[^>]*>/gi, (tag) => {
+      const src = tag.match(/\bsrc=(["'])(.*?)\1/i)?.[2] ?? '';
+      const alt = tag.match(/\balt=(["'])(.*?)\1/i)?.[2] ?? '';
+      if (src) images.push({ src, alt });
+      return '';
+    });
+    return { html: withoutImages.trim(), images };
+  }
+
+  const images: RichContentImage[] = [];
+  root.querySelectorAll('img').forEach((img) => {
+    const src = img.getAttribute('src') || '';
+    if (!src) return;
+    images.push({
+      src,
+      alt: img.getAttribute('alt') || '',
+    });
+    const host = img.closest('[data-uploading]');
+    host?.remove();
+    if (!host) img.remove();
+  });
+
+  root.querySelectorAll('[data-uploading]').forEach((node) => {
+    if (!node.querySelector('img')) node.remove();
+  });
+
+  return { html: root.innerHTML.trim(), images };
+};
+
+const parseGalleryImagesFromAttr = (raw: string | null): RichContentImage[] => {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .map((item) => {
+        if (typeof item === 'string' && item) return { src: item, alt: '' };
+        if (item && typeof item === 'object' && 'src' in item) {
+          const src = String((item as { src: unknown }).src || '');
+          if (!src || src.startsWith('blob:')) return null;
+          if (
+            'uploading' in item &&
+            (item as { uploading?: unknown }).uploading === true
+          ) {
+            return null;
+          }
+          const alt =
+            'alt' in item && typeof (item as { alt?: unknown }).alt === 'string'
+              ? (item as { alt: string }).alt
+              : '';
+          return { src, alt };
+        }
+        return null;
+      })
+      .filter((item): item is RichContentImage => item !== null);
+  } catch {
+    return [];
+  }
+};
+
+const collectRichVariantImages = (root: HTMLElement): RichContentImage[] => {
+  const images: RichContentImage[] = [];
+  const seen = new Set<string>();
+
+  const pushImage = (src: string, alt = '') => {
+    if (!src || seen.has(src)) return;
+    seen.add(src);
+    images.push({ src, alt });
+  };
+
+  root.querySelectorAll('[data-type="image-gallery"]').forEach((gallery) => {
+    const fromAttr = parseGalleryImagesFromAttr(gallery.getAttribute('data-images'));
+    if (fromAttr.length) {
+      fromAttr.forEach((image) => pushImage(image.src, image.alt));
+      return;
+    }
+    gallery.querySelectorAll('img').forEach((img) => {
+      pushImage(img.getAttribute('src') || '', img.getAttribute('alt') || '');
+    });
+  });
+
+  root.querySelectorAll('img').forEach((img) => {
+    if (img.closest('[data-type="image-gallery"]')) return;
+    pushImage(img.getAttribute('src') || '', img.getAttribute('alt') || '');
+  });
+
+  return images;
+};
+
+/**
+ * Подготавливает rich-контент: inline-картинки и галереи остаются в HTML.
+ */
+export const prepareRichVariantContent = (
+  content: string,
+): { html: string; images: RichContentImage[] } => {
+  const html = sanitizeBasicHtml(parseContentToHtml(content));
+  const root = parseHtmlRoot(html);
+
+  if (!root) {
+    const images: RichContentImage[] = [];
+    const imgRegex = /<img\b[^>]*>/gi;
+    const withoutInline = html.replace(imgRegex, (tag) => {
+      const src = tag.match(/\bsrc=(["'])(.*?)\1/i)?.[2] ?? '';
+      const alt = tag.match(/\balt=(["'])(.*?)\1/i)?.[2] ?? '';
+      if (src) images.push({ src, alt });
+      return tag;
+    });
+    return { html: setExternalLinksBlank(withoutInline.trim()), images };
+  }
+
+  const images = collectRichVariantImages(root);
+  return { html: setExternalLinksBlank(root.innerHTML.trim()), images };
+};
+
+/**
+ * Подготавливает контент к безопасному рендеру в UI:
+ * - markdown -> html (для legacy данных)
+ * - базовая очистка
+ * - внешние http/https ссылки в новой вкладке
+ */
+export const renderRichContent = (content: string): string => {
+  const { html } = splitRichContentImages(content);
+  return setExternalLinksBlank(html);
+};
+
+export const renderRichVariantContent = (content: string): string => {
+  return prepareRichVariantContent(content).html;
+};
+

package/src/shared/utils/safeRequest.ts

@@ -0,0 +1,23 @@
+export type ApiResult<T> =
+  | { ok: true; result: T; error: null }
+  | { ok: false; result: null; error: string };
+
+export async function safeRequest<T>(
+  fn: () => Promise<T>,
+): Promise<ApiResult<T>> {
+  try {
+    const result = await fn();
+
+    return {
+      ok: true,
+      result,
+      error: null,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      result: null,
+      error: err instanceof Error ? err.message : 'Unknown error',
+    };
+  }
+}

package/src/shared/utils/semver.ts

@@ -0,0 +1,81 @@
+/**
+ * Утилиты для работы с семантическими версиями
+ */
+
+/**
+ * Проверяет, является ли строка валидной семантической версией
+ * Формат: MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]
+ */
+export function isValidSemver(version: string): boolean {
+  const semverRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+  return semverRegex.test(version);
+}
+
+/**
+ * Сравнивает две семантические версии
+ * @returns -1 если v1 < v2, 0 если v1 === v2, 1 если v1 > v2
+ */
+export function compareVersions(v1: string, v2: string): number {
+  if (!isValidSemver(v1) || !isValidSemver(v2)) {
+    throw new Error('Invalid semver format');
+  }
+
+  // Парсим версии
+  const parseVersion = (v: string) => {
+    const [version, prerelease] = v.split('-');
+    const [major, minor, patch] = version.split('.').map(Number);
+    return { major, minor, patch, prerelease: prerelease || '' };
+  };
+
+  const parsed1 = parseVersion(v1);
+  const parsed2 = parseVersion(v2);
+
+  // Сравниваем major, minor, patch
+  if (parsed1.major !== parsed2.major) {
+    return parsed1.major > parsed2.major ? 1 : -1;
+  }
+  if (parsed1.minor !== parsed2.minor) {
+    return parsed1.minor > parsed2.minor ? 1 : -1;
+  }
+  if (parsed1.patch !== parsed2.patch) {
+    return parsed1.patch > parsed2.patch ? 1 : -1;
+  }
+
+  // Если версии одинаковые, сравниваем prerelease
+  if (parsed1.prerelease && !parsed2.prerelease) {
+    return -1; // prerelease версия меньше release
+  }
+  if (!parsed1.prerelease && parsed2.prerelease) {
+    return 1; // release версия больше prerelease
+  }
+  if (parsed1.prerelease && parsed2.prerelease) {
+    // Сравниваем prerelease строки лексикографически
+    return parsed1.prerelease > parsed2.prerelease ? 1 : parsed1.prerelease < parsed2.prerelease ? -1 : 0;
+  }
+
+  return 0;
+}
+
+/**
+ * Проверяет, что новая версия больше текущей
+ */
+export function isVersionGreater(newVersion: string, currentVersion: string): boolean {
+  try {
+    return compareVersions(newVersion, currentVersion) > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Проверяет, что версия не меньше текущей (больше или равна)
+ */
+export function isVersionNotLower(newVersion: string, currentVersion: string): boolean {
+  try {
+    return compareVersions(newVersion, currentVersion) >= 0;
+  } catch {
+    return false;
+  }
+}
+
+

package/src/shared/utils/serverPermissions.ts

@@ -0,0 +1,155 @@
+/**
+ * Утилиты для работы с правами доступа на серверах на клиенте
+ */
+
+import { ref, computed, watch, type ComputedRef, type Ref } from 'vue';
+import type { ServerMemberRole } from '../types/serverMember';
+import { useUserModel } from '@/models/user';
+import { useServersModel } from '@/models/projectServers';
+import { getServerMembers } from '../api/serverMembers';
+
+/**
+ * Получает роль текущего пользователя на сервере
+ * @param serverId - ID сервера
+ * @returns Роль пользователя или null, если пользователь не является участником
+ */
+export async function getCurrentUserServerRole(
+  serverId: string,
+): Promise<ServerMemberRole | null> {
+  const { user } = useUserModel();
+  const { selectedServer } = useServersModel();
+
+  if (!user.value) return null;
+
+  // Сначала проверяем, является ли пользователь автором проекта (если сервер в проекте)
+  const server = selectedServer.value;
+  if (server?.project?.author?.id === user.value.id) {
+    return 'admin';
+  }
+
+  // Затем проверяем участников сервера
+  const res = await getServerMembers(serverId);
+  if (res.ok) {
+    const currentUserMember = res.result.find((m) => m.user.id === user.value?.id);
+    if (currentUserMember) {
+      return currentUserMember.role;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Проверяет, является ли текущий пользователь участником сервера
+ * @param serverId - ID сервера
+ * @returns true, если пользователь является участником или автором проекта
+ */
+export async function isCurrentUserServerMember(
+  serverId: string,
+): Promise<boolean> {
+  const role = await getCurrentUserServerRole(serverId);
+  return role !== null;
+}
+
+/**
+ * Проверяет, имеет ли текущий пользователь права модератора или выше на сервере
+ * @param serverId - ID сервера
+ * @returns true, если пользователь является модератором или администратором
+ */
+export async function hasModeratorOrAdminRole(
+  serverId: string,
+): Promise<boolean> {
+  const role = await getCurrentUserServerRole(serverId);
+  return role === 'moderator' || role === 'admin';
+}
+
+/**
+ * Проверяет, имеет ли текущий пользователь права администратора на сервере
+ * @param serverId - ID сервера
+ * @returns true, если пользователь является администратором
+ */
+export async function hasAdminRole(serverId: string): Promise<boolean> {
+  const role = await getCurrentUserServerRole(serverId);
+  return role === 'admin';
+}
+
+/**
+ * Создает computed свойство для проверки роли пользователя на сервере
+ * @param serverId - ID сервера (может быть ref, computed или функция)
+ * @returns Computed свойство с ролью пользователя
+ */
+export function useServerRole(
+  serverId:
+    | ComputedRef<string | null>
+    | Ref<string | null>
+    | (() => string | null),
+) {
+  const { user } = useUserModel();
+  const { selectedServer } = useServersModel();
+
+  const role = ref<ServerMemberRole | null>(null);
+  const isLoading = ref(false);
+
+  const loadRole = async () => {
+    const id =
+      typeof serverId === 'function' ? serverId() : (serverId as any).value;
+    if (!id || !user.value) {
+      role.value = null;
+      return;
+    }
+
+    isLoading.value = true;
+    try {
+      // Проверяем, является ли пользователь автором проекта
+      const server = selectedServer.value;
+      if (server?.project?.author?.id === user.value.id) {
+        role.value = 'admin';
+        isLoading.value = false;
+        return;
+      }
+
+      // Проверяем участников сервера
+      const res = await getServerMembers(id);
+      if (res.ok) {
+        const currentUserMember = res.result.find(
+          (m) => m.user.id === user.value?.id,
+        );
+        role.value = currentUserMember?.role || null;
+      } else {
+        console.error('[useServerRole] Error loading role:', res.error);
+        role.value = null;
+      }
+    } finally {
+      isLoading.value = false;
+    }
+  };
+
+  watch(
+    () => {
+      const id =
+        typeof serverId === 'function' ? serverId() : (serverId as any).value;
+      return id;
+    },
+    () => {
+      loadRole();
+    },
+    { immediate: true },
+  );
+
+  const isMember = computed(() => role.value !== null);
+  const isModerator = computed(
+    () => role.value === 'moderator' || role.value === 'admin',
+  );
+  const isAdmin = computed(() => role.value === 'admin');
+  const isPlayer = computed(() => role.value === 'player');
+
+  return {
+    role: computed(() => role.value),
+    isLoading: computed(() => isLoading.value),
+    isMember,
+    isModerator,
+    isAdmin,
+    isPlayer,
+    refresh: loadRole,
+  };
+}