@rynt/sdk 0.9.53

package/src/shared/minecraft-types/minecraft-launcher-types.ts

@@ -0,0 +1,276 @@
+/**
+ * Общие контракты для @rynt/minecraft-launcher и расширений (useModel('launcher')).
+ * Единый источник: SDK не зависит от пакета minecraft-launcher.
+ */
+
+import type { ChildProcess } from 'node:child_process';
+import type { ComputedRef, Ref } from 'vue';
+
+import type { Download, Library, Rule, VersionAsset } from './build-manifest';
+import type {
+  LoaderGameVersion,
+  LoaderVersionSummary,
+  MinecraftVersion,
+  MinecraftVersionManifest,
+} from './launcher-versions';
+
+export type {
+  LoaderGameVersion,
+  LoaderVersionSummary,
+  MinecraftVersion,
+  MinecraftVersionManifest,
+};
+
+export interface MinecraftVersionDetails {
+  id: string;
+  type: string;
+  mainClass: string;
+  inheritsFrom?: string;
+  minecraftArguments?: string;
+  versionAssets?: VersionAsset[];
+  arguments?: {
+    game: (string | { rules?: Rule[]; value: string | string[] })[];
+    jvm: (string | { rules?: Rule[]; value: string | string[] })[];
+  };
+  libraries: Library[];
+  assetIndex: AssetIndex;
+  downloads: {
+    client: Download;
+    server?: Download;
+    client_mappings?: Download;
+    server_mappings?: Download;
+  };
+  javaVersion?: {
+    component: string;
+    majorVersion: number;
+  };
+  minimumLauncherVersion?: number;
+}
+
+export interface AssetIndex {
+  id: string;
+  sha1: string;
+  size: number;
+  totalSize: number;
+  url: string;
+}
+
+export interface AssetManifest {
+  map_to_resources?: boolean;
+  objects: {
+    [key: string]: {
+      hash: string;
+      size: number;
+    };
+  };
+}
+
+export interface FabricLoaderVersion {
+  separator: string;
+  build: number;
+  maven: string;
+  version: string;
+}
+
+export interface FabricGameVersion {
+  version: string;
+  stable: boolean;
+}
+
+export interface FabricInstallerVersion {
+  url: string;
+  maven: string;
+  version: string;
+  stable: boolean;
+}
+
+export interface FabricVersionInfo {
+  loader: FabricLoaderVersion;
+  intermediary: {
+    maven: string;
+    version: string;
+  };
+  launcherMeta: {
+    version: number;
+    libraries: {
+      client: Library[];
+      common: Library[];
+      server: Library[];
+    };
+    mainClass: {
+      client: string;
+      server: string;
+    };
+  };
+}
+
+export interface NodeModules {
+  child_process?: typeof import('node:child_process');
+  fs?: typeof import('node:fs');
+  path?: typeof import('node:path');
+  os?: typeof import('node:os');
+  crypto?: typeof import('node:crypto');
+  axios?: typeof import('axios').default;
+  'adm-zip'?: unknown;
+  /**
+   * Resolved at runtime via NW.js / minecraft-launcher (`@xmcl/core` is not an SDK dependency).
+   * Typed as unknown here so packages that only import SDK types (e.g. marketplace-service) can compile.
+   */
+  '@xmcl/core'?: unknown;
+}
+
+export interface LauncherConfig {
+  baseDirectory?: string;
+  nodeModules?: NodeModules;
+  versionsDirectory?: string;
+  librariesDirectory?: string;
+  assetsDirectory?: string;
+  logsDirectory?: string;
+  savesDirectory?: string;
+  javaPath?: string;
+  minMemory?: number;
+  maxMemory?: number;
+  jvmArguments?: string[];
+  gameArguments?: string[];
+  versionManifestUrl?: string;
+  assetsUrl?: string;
+  librariesUrl?: string;
+  downloadConcurrency?: number;
+  downloadRetries?: number;
+  downloadRetryDelayMs?: number;
+}
+
+export interface LaunchOptions {
+  version: string;
+  buildName?: string;
+  loaderId?: string;
+  loaderVersion?: string;
+  ignoreVersionAssets?: boolean;
+  username: string;
+  uuid?: string;
+  accessToken?: string;
+  clientToken?: string;
+  gameDirectory?: string;
+  versionsDirectory?: string;
+  javaPath?: string;
+  memory?: {
+    min?: number;
+    max?: number;
+  };
+  jvmArguments?: string[];
+  gameArguments?: string[];
+  width?: number;
+  height?: number;
+  fullscreen?: boolean;
+  server?: {
+    ip: string;
+    port?: number;
+  };
+  authlibInjectorUrl?: string;
+  minecraftApiArgs?: Record<string, string>;
+}
+
+export interface DownloadProgress {
+  file: string;
+  downloaded: number;
+  total: number;
+  percentage: number;
+}
+
+export interface LaunchProgress {
+  stage:
+    | 'downloading'
+    | 'extracting'
+    | 'validating'
+    | 'verifying'
+    | 'launching'
+    | 'running'
+    | 'cancelled';
+  progress?: DownloadProgress;
+  message?: string;
+}
+
+/** Результат `resolvePaths(config)` в composable */
+export interface MinecraftLauncherResolvedPaths {
+  base: string;
+  versions: string;
+  libraries: string;
+  assets: string;
+  logs: string;
+  jre: string;
+  indexes: string;
+  objects: string;
+  natives: string;
+}
+
+export type LauncherLogLevel = 'info' | 'warn' | 'error';
+
+export interface LauncherLogEntry {
+  at: string;
+  level: LauncherLogLevel;
+  message: string;
+}
+
+/**
+ * Публичный return-объект `useMinecraftLauncher()`.
+ * Должен совпадать с реализацией в @rynt/minecraft-launcher.
+ */
+export interface UseMinecraftLauncherApi {
+  config: Ref<LauncherConfig>;
+  isDownloading: Ref<boolean>;
+  isLaunching: Ref<boolean>;
+  progress: Ref<LaunchProgress | null>;
+  error: Ref<Error | null>;
+  gameProcess: Ref<ChildProcess | null>;
+  gameLogs: Ref<string[]>;
+  launcherLogs: Ref<LauncherLogEntry[]>;
+  versionManifest: Ref<MinecraftVersionManifest | null>;
+
+  paths: ComputedRef<MinecraftLauncherResolvedPaths>;
+
+  updateConfig: (updates: Partial<LauncherConfig>) => void;
+  findJavaPath: (baseDirectory?: string) => string;
+  generateOfflineTokens: () => { accessToken: string; clientToken: string; uuid: string };
+  loadVersionManifest: () => Promise<MinecraftVersionManifest>;
+  getVersionInfo: (versionId: string, _buildDir?: string) => Promise<MinecraftVersionDetails>;
+
+  getLoaders: () => Promise<{ id: string; name: string }[]>;
+  getLoaderGameVersions: (loaderId: string) => Promise<LoaderGameVersion[]>;
+  getLoaderVersions: (loaderId: string, gameVersion: string) => Promise<LoaderVersionSummary[]>;
+
+  downloadVersion: (
+    versionId: string,
+    loaderId?: string,
+    loaderVersion?: string,
+    buildName?: string,
+    onProgress?: (progress: LaunchProgress) => void,
+    ignoreVersionAssets?: boolean,
+    customVersionsDir?: string,
+  ) => Promise<void>;
+
+  verifyFiles: (
+    versionId: string,
+    loaderId?: string,
+    loaderVersion?: string,
+    buildName?: string,
+    ignoreVersionAssets?: boolean,
+    customVersionsDir?: string,
+  ) => Promise<{ missing: string[]; invalid: string[] }>;
+
+  launch: (
+    options: LaunchOptions,
+    onProgress?: (progress: LaunchProgress) => void,
+  ) => Promise<ChildProcess>;
+
+  downloadAndLaunch: (
+    options: LaunchOptions,
+    onProgress?: (progress: LaunchProgress) => void,
+  ) => Promise<ChildProcess>;
+
+  killProcess: (processId: string, signal?: NodeJS.Signals | number) => boolean;
+  getProcess: (processId: string) => ChildProcess | null;
+  isProcessRunning: (processId: string) => boolean;
+  stopDownload: (reason?: string) => Promise<void>;
+}
+
+export type UseMinecraftLauncherReturn = UseMinecraftLauncherApi;

package/src/shared/mocks/index.ts

@@ -0,0 +1 @@
+export * from './navigation';

package/src/shared/mocks/navigation.ts

@@ -0,0 +1,17 @@
+import type { NavigationSection, MenuItem } from '../types';
+
+export const mockSections: NavigationSection[] = [
+  { link: '/', label: 'Главная', icon: 'home' },
+  { link: '/builds', label: 'Сборки', icon: 'box' },
+  { link: '/servers', label: 'Серверы', icon: 'server' },
+  { link: '/friends', label: 'Друзья', icon: 'users' },
+  { link: '/settings', label: 'Настройки', icon: 'settings' },
+  { link: '/library', label: 'Библиотека', icon: 'search' },
+];
+
+export const mockMenuItems: MenuItem[] = [
+  { id: 'profile', label: 'Профиль', icon: 'user' },
+  { id: 'settings', label: 'Настройки', icon: 'settings' },
+  { id: 'logout', label: 'Выйти', icon: 'close' },
+];
+

package/src/shared/mods/http.ts

@@ -0,0 +1,45 @@
+/**
+ * Build URL with query parameters
+ */
+function buildUrl(baseUrl: string, params?: Record<string, string | number | boolean | undefined>): string {
+  if (!params) return baseUrl;
+  
+  const url = new URL(baseUrl);
+  Object.entries(params).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      url.searchParams.append(key, String(value));
+    }
+  });
+  return url.toString();
+}
+
+/**
+ * Fetch wrapper that works in both browser and NW.js
+ * Uses native fetch API so requests are visible in Network tab
+ */
+export async function httpGet<T>(
+  url: string,
+  options?: {
+    params?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+  }
+): Promise<T> {
+  const fullUrl = buildUrl(url, options?.params);
+  
+  const response = await fetch(fullUrl, {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      ...options?.headers,
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => 'Unknown error');
+    throw new Error(`HTTP ${response.status}: ${errorText}`);
+  }
+
+  return response.json() as Promise<T>;
+}
+
+

package/src/shared/mods/index.ts

@@ -0,0 +1,5 @@
+export * from './providers';
+export * from './http';
+export * from './mod-marketplace-registry';
+export * from './mod-marketplace-types';
+export * from './types';

package/src/shared/mods/marketplace-editor-search.ts

@@ -0,0 +1,266 @@
+import type { Ref } from 'vue';
+import { reactive, ref, type Reactive } from 'vue';
+
+import type { BuildVersionManifest } from '../minecraft-types/build-manifest';
+import {
+  getModMarketplaceProvider,
+  listModMarketplaceProviders,
+} from './mod-marketplace-registry';
+import {
+  mergeMarketplaceItems,
+  runMarketplaceSearch,
+} from './marketplace-search-utils';
+import type {
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  ProjectType,
+} from './types';
+
+export type MarketplaceEditorSearchBindings = {
+  manifest: Ref<BuildVersionManifest | null>;
+  searchQuery: Ref<string>;
+  isSearching: Ref<boolean>;
+  searchError: Ref<string | null>;
+  searchResultsByProvider: Reactive<Record<string, MarketplaceItem[]>>;
+  isSearchingByProvider: Reactive<Record<string, boolean>>;
+  isLoadingMoreByProvider: Reactive<Record<string, boolean>>;
+  hasMoreByProvider: Reactive<Record<string, boolean>>;
+  searchPageByProvider: Reactive<Record<string, number>>;
+  marketplaceBrowseStarted: Ref<boolean>;
+  marketplaceTab: Ref<string>;
+};
+
+export type MarketplaceEditorSearchOptions = {
+  projectType: ProjectType;
+  logTag: string;
+  buildBaseSearchContext?: (
+    manifest: BuildVersionManifest | null,
+    query: string,
+  ) => Omit<MarketplaceSearchContext, 'page' | 'query'>;
+};
+
+export function createMarketplaceEditorSearch(
+  bindings: MarketplaceEditorSearchBindings,
+  options: MarketplaceEditorSearchOptions,
+) {
+  const {
+    manifest,
+    searchQuery,
+    isSearching,
+    searchError,
+    searchResultsByProvider,
+    isSearchingByProvider,
+    isLoadingMoreByProvider,
+    hasMoreByProvider,
+    searchPageByProvider,
+    marketplaceBrowseStarted,
+    marketplaceTab,
+  } = bindings;
+
+  function syncMarketplaceProviderSearchKeys(): void {
+    for (const p of listModMarketplaceProviders()) {
+      if (!(p.id in searchResultsByProvider)) {
+        searchResultsByProvider[p.id] = [];
+      }
+      if (!(p.id in isSearchingByProvider)) {
+        isSearchingByProvider[p.id] = false;
+      }
+      if (!(p.id in isLoadingMoreByProvider)) {
+        isLoadingMoreByProvider[p.id] = false;
+      }
+      if (!(p.id in hasMoreByProvider)) {
+        hasMoreByProvider[p.id] = false;
+      }
+      if (!(p.id in searchPageByProvider)) {
+        searchPageByProvider[p.id] = -1;
+      }
+    }
+  }
+
+  function getProvidersForLoadMore(tabId: string): string[] {
+    syncMarketplaceProviderSearchKeys();
+    if (tabId === 'all') {
+      return listModMarketplaceProviders()
+        .map((p) => p.id)
+        .filter((id) => hasMoreByProvider[id]);
+    }
+    return hasMoreByProvider[tabId] ? [tabId] : [];
+  }
+
+  function canLoadMoreMarketplace(tabId: string): boolean {
+    return getProvidersForLoadMore(tabId).length > 0;
+  }
+
+  function isLoadingMoreMarketplace(tabId: string): boolean {
+    syncMarketplaceProviderSearchKeys();
+    if (tabId === 'all') {
+      return listModMarketplaceProviders().some(
+        (p) => isLoadingMoreByProvider[p.id],
+      );
+    }
+    return Boolean(isLoadingMoreByProvider[tabId]);
+  }
+
+  function buildBaseSearchContext(query: string): MarketplaceSearchContext {
+    if (options.buildBaseSearchContext) {
+      return {
+        ...options.buildBaseSearchContext(manifest.value, query),
+        query,
+      };
+    }
+    return {
+      projectType: options.projectType,
+      query,
+      minecraftVersion:
+        manifest.value?._meta?.manifest?.minecraftVersion || undefined,
+    };
+  }
+
+  async function searchProvider(
+    providerId: string,
+    reset: boolean,
+    baseSearchCtx: MarketplaceSearchContext,
+  ): Promise<void> {
+    const prov = getModMarketplaceProvider(providerId);
+    if (!prov) return;
+
+    const page = reset ? 0 : (searchPageByProvider[providerId] ?? -1) + 1;
+    const ctx: MarketplaceSearchContext = { ...baseSearchCtx, page };
+
+    if (reset) {
+      isSearchingByProvider[providerId] = true;
+    } else {
+      isLoadingMoreByProvider[providerId] = true;
+    }
+
+    try {
+      const result = await runMarketplaceSearch(prov, ctx);
+      if (reset) {
+        searchResultsByProvider[providerId] = result.items;
+      } else {
+        searchResultsByProvider[providerId] = mergeMarketplaceItems(
+          searchResultsByProvider[providerId] ?? [],
+          result.items,
+        );
+      }
+      hasMoreByProvider[providerId] = result.hasMore;
+      searchPageByProvider[providerId] = page;
+    } catch (e) {
+      console.warn(`[${options.logTag}] ${providerId} search failed:`, e);
+      if (reset) {
+        searchResultsByProvider[providerId] = [];
+        hasMoreByProvider[providerId] = false;
+        searchPageByProvider[providerId] = -1;
+      }
+    } finally {
+      if (reset) {
+        isSearchingByProvider[providerId] = false;
+      } else {
+        isLoadingMoreByProvider[providerId] = false;
+      }
+    }
+  }
+
+  async function searchProviders(
+    providerIds: string[],
+    reset: boolean,
+  ): Promise<void> {
+    syncMarketplaceProviderSearchKeys();
+    marketplaceBrowseStarted.value = true;
+
+    const baseSearchCtx = buildBaseSearchContext(searchQuery.value);
+
+    if (reset) {
+      isSearching.value = true;
+      searchError.value = null;
+      for (const id of providerIds) {
+        searchResultsByProvider[id] = [];
+        hasMoreByProvider[id] = false;
+        searchPageByProvider[id] = -1;
+      }
+    }
+
+    try {
+      await Promise.allSettled(
+        providerIds.map((id) => searchProvider(id, reset, baseSearchCtx)),
+      );
+    } catch (e) {
+      searchError.value = e instanceof Error ? e.message : String(e);
+    } finally {
+      if (reset) {
+        isSearching.value = false;
+      }
+    }
+  }
+
+  async function search(reset = true): Promise<void> {
+    const allIds = listModMarketplaceProviders().map((p) => p.id);
+    await searchProviders(allIds, reset);
+  }
+
+  async function loadMoreMarketplaceResults(): Promise<void> {
+    if (isSearching.value) return;
+    const tabId = marketplaceTab.value;
+    const providerIds = getProvidersForLoadMore(tabId);
+    if (!providerIds.length) return;
+    if (isLoadingMoreMarketplace(tabId)) return;
+    await searchProviders(providerIds, false);
+  }
+
+  function getMarketplaceSearchResults(tabId: string): MarketplaceItem[] {
+    syncMarketplaceProviderSearchKeys();
+    if (tabId === 'all') {
+      const merged: MarketplaceItem[] = [];
+      for (const p of listModMarketplaceProviders()) {
+        merged.push(...(searchResultsByProvider[p.id] ?? []));
+      }
+      return merged;
+    }
+    return searchResultsByProvider[tabId] ?? [];
+  }
+
+  function isMarketplaceTabSearching(tabId: string): boolean {
+    syncMarketplaceProviderSearchKeys();
+    if (tabId === 'all') {
+      return listModMarketplaceProviders().some(
+        (p) => isSearchingByProvider[p.id],
+      );
+    }
+    return Boolean(isSearchingByProvider[tabId]);
+  }
+
+  function resetMarketplaceSearchState(): void {
+    syncMarketplaceProviderSearchKeys();
+    for (const p of listModMarketplaceProviders()) {
+      searchResultsByProvider[p.id] = [];
+      isSearchingByProvider[p.id] = false;
+      isLoadingMoreByProvider[p.id] = false;
+      hasMoreByProvider[p.id] = false;
+      searchPageByProvider[p.id] = -1;
+    }
+  }
+
+  return {
+    syncMarketplaceProviderSearchKeys,
+    canLoadMoreMarketplace,
+    isLoadingMoreMarketplace,
+    search,
+    loadMoreMarketplaceResults,
+    getMarketplaceSearchResults,
+    isMarketplaceTabSearching,
+    resetMarketplaceSearchState,
+  };
+}
+
+export function createMarketplaceEditorSearchState() {
+  return {
+    isSearching: ref(false),
+    searchError: ref<string | null>(null),
+    searchResultsByProvider: reactive<Record<string, MarketplaceItem[]>>({}),
+    isSearchingByProvider: reactive<Record<string, boolean>>({}),
+    isLoadingMoreByProvider: reactive<Record<string, boolean>>({}),
+    hasMoreByProvider: reactive<Record<string, boolean>>({}),
+    searchPageByProvider: reactive<Record<string, number>>({}),
+    marketplaceBrowseStarted: ref(false),
+  };
+}

package/src/shared/mods/marketplace-search-utils.ts

@@ -0,0 +1,42 @@
+import type { ModMarketplaceProvider } from './mod-marketplace-types';
+import type {
+  MarketplaceItem,
+  MarketplaceSearchContext,
+  MarketplaceSearchResult,
+} from './types';
+import { MARKETPLACE_SEARCH_PAGE_SIZE as PAGE_SIZE } from './types';
+
+export async function runMarketplaceSearch(
+  provider: ModMarketplaceProvider,
+  ctx: MarketplaceSearchContext,
+): Promise<MarketplaceSearchResult> {
+  const result = await provider.search(ctx);
+  return normalizeMarketplaceSearchResult(result);
+}
+
+export function normalizeMarketplaceSearchResult(
+  result: MarketplaceSearchResult | MarketplaceItem[],
+): MarketplaceSearchResult {
+  if (Array.isArray(result)) {
+    return {
+      items: result,
+      hasMore: result.length >= PAGE_SIZE,
+    };
+  }
+  return result;
+}
+
+export function mergeMarketplaceItems(
+  existing: MarketplaceItem[],
+  incoming: MarketplaceItem[],
+): MarketplaceItem[] {
+  const seen = new Set(existing.map((i) => `${i.provider}:${i.projectId}`));
+  const merged = [...existing];
+  for (const item of incoming) {
+    const key = `${item.provider}:${item.projectId}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    merged.push(item);
+  }
+  return merged;
+}