@rynt/sdk 0.9.53

package/src/shared/composables/shaderPacksEditor/shaderPacksEditor.ts

@@ -0,0 +1,395 @@
+import { defineStore } from '../../definitions/defineStore';
+import { computed, ref, watch, type Ref } from 'vue';
+import { debounce } from 'lodash-es';
+import type {
+  BuildVersionManifest,
+  ShaderPack,
+} from '../../minecraft-types/build-manifest';
+import { useLocalBuildsModel } from '@/models';
+import type { MarketplaceItem } from '../../mods/types';
+import type { ProjectDetails } from '../../mods/types';
+import {
+  createMarketplaceEditorSearch,
+  createMarketplaceEditorSearchState,
+} from '../../mods/marketplace-editor-search';
+import { getModMarketplaceProvider } from '../../mods/mod-marketplace-registry';
+import { listModMarketplaceProviders } from '../../mods/mod-marketplace-registry';
+import {
+  scanLocalShaderPacks,
+  toggleShaderPackDisabled,
+  deleteLocalShaderPack,
+} from '../../utils/local-mods';
+
+export type ShaderPacksEditorMarketplaceTab = string;
+
+export const useShaderPacksEditorModel = defineStore(
+  (_manifestRef: Ref<BuildVersionManifest | null>) => {
+    const manifest = _manifestRef;
+
+    const searchQuery = ref('');
+    const marketplaceTab = ref<ShaderPacksEditorMarketplaceTab>('all');
+
+    const marketplaceSearchState = createMarketplaceEditorSearchState();
+    const { isSearching, searchError, marketplaceBrowseStarted } =
+      marketplaceSearchState;
+
+    const marketplaceSearch = createMarketplaceEditorSearch(
+      {
+        manifest,
+        searchQuery,
+        marketplaceTab,
+        ...marketplaceSearchState,
+      },
+      {
+        projectType: 'shaderpack',
+        logTag: 'shaderPacksEditor',
+      },
+    );
+
+    const selectedShaderPackDetails = ref<ProjectDetails | null>(null);
+    const isLoadingShaderPackDetails = ref(false);
+    const shaderPackDetailsError = ref<string | null>(null);
+
+    const originalManifest = ref<BuildVersionManifest | null>(null);
+
+    const localShaderPacks = ref<ShaderPack[]>([]);
+
+    const installedShaderPacks = computed<ShaderPack[]>(
+      () => (manifest.value?.shaderPacks ?? []) as ShaderPack[],
+    );
+
+    const allShaderPacks = computed<ShaderPack[]>(() => [
+      ...installedShaderPacks.value,
+      ...localShaderPacks.value,
+    ]);
+
+    function isInstalledBySlug(slug: string): boolean {
+      return installedShaderPacks.value.some(
+        (sp) => sp.projectSlug === slug || sp.id === slug,
+      );
+    }
+
+    async function install(item: MarketplaceItem) {
+      if (!manifest.value) return;
+      const mc = manifest.value._meta?.manifest?.minecraftVersion;
+      if (!mc || mc.trim() === '') return;
+
+      const installCtx = {
+        projectType: 'shaderpack' as const,
+        minecraftVersion:
+          manifest.value?._meta?.manifest?.minecraftVersion || '',
+        loader: 'vanilla' as const,
+      } as const;
+
+      const prov = getModMarketplaceProvider(item.provider);
+      if (!prov) {
+        console.warn(
+          `[shaderPacksEditor] Unknown marketplace provider: ${item.provider}`,
+        );
+        return;
+      }
+      const shaderPack = (await prov.install(item, installCtx)) as ShaderPack;
+
+      const isAlreadyInstalled = installedShaderPacks.value.some(
+        (sp) =>
+          sp.projectSlug === shaderPack.projectSlug || sp.id === shaderPack.id,
+      );
+
+      if (isAlreadyInstalled) {
+        console.warn(
+          `[shaderPacksEditor] Shader pack ${shaderPack.name} is already installed`,
+        );
+        return;
+      }
+
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      if (
+        shaderPack.constraints &&
+        shaderPack.constraints.minecraft !== currentMc
+      ) {
+        console.warn(
+          `[shaderPacksEditor] Shader pack ${shaderPack.name} is for Minecraft ${shaderPack.constraints.minecraft}, but selected version is ${currentMc}`,
+        );
+      }
+
+      const allShaderPacksList = [...installedShaderPacks.value];
+      allShaderPacksList.push(shaderPack);
+      manifest.value.shaderPacks = allShaderPacksList;
+    }
+
+    function removeInstalled(idOrSlug: string) {
+      if (!manifest.value) return;
+
+      const allShaderPacksList = [...installedShaderPacks.value];
+      manifest.value.shaderPacks = allShaderPacksList.filter(
+        (sp) => sp.id !== idOrSlug && sp.projectSlug !== idOrSlug,
+      );
+    }
+
+    async function loadShaderPackDetails(item: MarketplaceItem) {
+      isLoadingShaderPackDetails.value = true;
+      shaderPackDetailsError.value = null;
+      try {
+        const prov = getModMarketplaceProvider(item.provider);
+        if (!prov) {
+          throw new Error(`Unknown provider: ${item.provider}`);
+        }
+        const details = await prov.getProjectDetails(item.projectId);
+        selectedShaderPackDetails.value = details;
+      } catch (e) {
+        shaderPackDetailsError.value =
+          e instanceof Error ? e.message : String(e);
+        selectedShaderPackDetails.value = null;
+      } finally {
+        isLoadingShaderPackDetails.value = false;
+      }
+    }
+
+    async function loadInstalledShaderPackDetails(shaderPack: ShaderPack) {
+      isLoadingShaderPackDetails.value = true;
+      shaderPackDetailsError.value = null;
+      try {
+        let details: ProjectDetails | null = null;
+        const prov = getModMarketplaceProvider(shaderPack.source);
+        if (prov) {
+          details = await prov.getProjectDetails(shaderPack.id);
+        }
+        if (details) {
+          selectedShaderPackDetails.value = details;
+        } else {
+          selectedShaderPackDetails.value = {
+            provider: shaderPack.source as ProjectDetails['provider'],
+            projectId: shaderPack.id,
+            slug: shaderPack.projectSlug || shaderPack.id,
+            name: shaderPack.name,
+            summary: 'Локальный шейдер',
+            iconUrl: shaderPack.image || '',
+            downloads: 0,
+          };
+        }
+      } catch (e) {
+        shaderPackDetailsError.value =
+          e instanceof Error ? e.message : String(e);
+        selectedShaderPackDetails.value = null;
+      } finally {
+        isLoadingShaderPackDetails.value = false;
+      }
+    }
+
+    function clearShaderPackDetails() {
+      selectedShaderPackDetails.value = null;
+      shaderPackDetailsError.value = null;
+    }
+
+    function checkShaderPackCompatibility(shaderPack: ShaderPack): {
+      isValid: boolean;
+      reason?: string;
+    } {
+      if (!shaderPack.constraints) {
+        return { isValid: true };
+      }
+
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      const mcMatch = shaderPack.constraints.minecraft === currentMc;
+
+      if (!mcMatch) {
+        return {
+          isValid: false,
+          reason: `Minecraft ${shaderPack.constraints.minecraft} (выбрано: ${currentMc})`,
+        };
+      }
+
+      return { isValid: true };
+    }
+
+    const shaderPacksCompatibilityStatus = computed(() => {
+      const status = new Map<string, { isValid: boolean; reason?: string }>();
+      const installed = installedShaderPacks.value;
+
+      for (const sp of installed) {
+        const spKey = sp.id || sp.projectSlug;
+        status.set(spKey, checkShaderPackCompatibility(sp));
+      }
+
+      return status;
+    });
+
+    const activeSearchResults = computed(() =>
+      marketplaceSearch.getMarketplaceSearchResults(marketplaceTab.value),
+    );
+
+    let debouncedSearch = debounce(() => {
+      void marketplaceSearch.search(true);
+    }, 500);
+
+    let stopWatcher: (() => void) | null = null;
+
+    function setupSearchWatcher() {
+      if (stopWatcher) {
+        stopWatcher();
+      }
+
+      stopWatcher = watch(searchQuery, () => {
+        debouncedSearch();
+      });
+    }
+
+    setupSearchWatcher();
+
+    watch(
+      () => manifest.value?._meta?.manifest?.minecraftVersion,
+      () => {
+        if (!marketplaceBrowseStarted.value) return;
+        void marketplaceSearch.search(true);
+      },
+    );
+
+    function scanLocalShaderPacksList() {
+      if (!manifest.value?.id) return;
+
+      const localBuilds = useLocalBuildsModel();
+      const original = localBuilds.getManifestById(manifest.value.id);
+      originalManifest.value = original;
+
+      localShaderPacks.value = scanLocalShaderPacks(
+        manifest.value.id,
+        original,
+      );
+    }
+
+    function toggleShaderPackDisabledState(
+      shaderPack: ShaderPack,
+      disabled: boolean,
+    ) {
+      if (!manifest.value?.id) return false;
+
+      if (
+        shaderPack.source === 'direct' &&
+        shaderPack.id.startsWith('local-')
+      ) {
+        const success = toggleShaderPackDisabled(
+          manifest.value.id,
+          shaderPack,
+          disabled,
+        );
+        if (success) {
+          shaderPack.disabled = disabled;
+          if (shaderPack.files.length > 0) {
+            const file = shaderPack.files[0];
+            if (disabled) {
+              file.path = file.path.replace(/\.zip$/, '.zip.disabled');
+            } else {
+              file.path = file.path.replace(/\.disabled$/, '');
+            }
+          }
+        }
+        return success;
+      } else {
+        if (!manifest.value.shaderPacks) return false;
+
+        const spIndex = manifest.value.shaderPacks.findIndex(
+          (sp) => sp.id === shaderPack.id,
+        );
+        if (spIndex >= 0) {
+          const success = toggleShaderPackDisabled(
+            manifest.value.id,
+            shaderPack,
+            disabled,
+          );
+          if (!success) return false;
+
+          manifest.value.shaderPacks[spIndex].disabled = disabled;
+          for (const file of manifest.value.shaderPacks[spIndex].files) {
+            if (disabled) {
+              if (!file.path.endsWith('.disabled')) {
+                file.path = `${file.path}.disabled`;
+              }
+              if (!file.filename.endsWith('.disabled')) {
+                file.filename = `${file.filename}.disabled`;
+              }
+            } else {
+              file.path = file.path.replace(/\.disabled$/, '');
+              file.filename = file.filename.replace(/\.disabled$/, '');
+            }
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+
+    function deleteLocalShaderPackFile(shaderPack: ShaderPack) {
+      if (!manifest.value?.id) return false;
+
+      if (
+        shaderPack.source === 'direct' &&
+        shaderPack.id.startsWith('local-')
+      ) {
+        const success = deleteLocalShaderPack(manifest.value.id, shaderPack);
+        if (success) {
+          localShaderPacks.value = localShaderPacks.value.filter(
+            (sp) => sp.id !== shaderPack.id,
+          );
+        }
+        return success;
+      }
+      return false;
+    }
+
+    const init = async (_manifest: BuildVersionManifest | null) => {
+      searchQuery.value = '';
+      searchError.value = null;
+      isSearching.value = false;
+      selectedShaderPackDetails.value = null;
+      shaderPackDetailsError.value = null;
+      marketplaceSearch.resetMarketplaceSearchState();
+
+      const validTabs = new Set<string>([
+        'all',
+        ...listModMarketplaceProviders().map((p) => p.id),
+      ]);
+      if (!validTabs.has(marketplaceTab.value)) {
+        marketplaceTab.value = 'all';
+      }
+
+      setupSearchWatcher();
+
+      void marketplaceSearch.search(true);
+
+      scanLocalShaderPacksList();
+    };
+
+    return {
+      init,
+      marketplaceTab,
+      searchQuery,
+      isSearching,
+      searchError,
+      activeSearchResults,
+      getMarketplaceSearchResults: marketplaceSearch.getMarketplaceSearchResults,
+      isMarketplaceTabSearching: marketplaceSearch.isMarketplaceTabSearching,
+      loadMoreMarketplaceResults: marketplaceSearch.loadMoreMarketplaceResults,
+      canLoadMoreMarketplace: marketplaceSearch.canLoadMoreMarketplace,
+      isLoadingMoreMarketplace: marketplaceSearch.isLoadingMoreMarketplace,
+      marketplaceBrowseStarted,
+      installedShaderPacks,
+      allShaderPacks,
+      localShaderPacks,
+      isInstalledBySlug,
+      selectedShaderPackDetails,
+      isLoadingShaderPackDetails,
+      shaderPackDetailsError,
+      search: marketplaceSearch.search,
+      install,
+      removeInstalled,
+      loadShaderPackDetails,
+      loadInstalledShaderPackDetails,
+      clearShaderPackDetails,
+      shaderPacksCompatibilityStatus,
+      scanLocalShaderPacksList,
+      toggleShaderPackDisabledState,
+      deleteLocalShaderPackFile,
+    };
+  },
+  false,
+);

package/src/shared/composables/useSkinRender.ts

@@ -0,0 +1,70 @@
+/**
+ * Composable для получения рендера скина с кешированием
+ */
+
+import { ref, computed, watch } from 'vue';
+import { getAccountSkinRender } from '../utils/getAccountSkinRender';
+import type { MinecraftAccount } from '../types/account';
+
+/**
+ * Получить рендер скина для аккаунта (MinecraftAccount)
+ */
+export function useSkinRender(account: MinecraftAccount | null | undefined) {
+  const renderUrl = ref<string | null>(null);
+  const isLoading = ref(false);
+  const error = ref<string | null>(null);
+
+  const loadRender = async () => {
+    if (!account?.avatar) {
+      renderUrl.value = null;
+      return;
+    }
+
+    // Проверяем, что мы в NW.js окружении
+    if (typeof window === 'undefined' || !(window as any).nw) {
+      renderUrl.value = account.avatar;
+      return;
+    }
+
+    // Проверяем, что avatar - это валидный URL (http/https) или локальный путь (file:// или относительный)
+    const isHttpUrl = account.avatar.startsWith('http://') || account.avatar.startsWith('https://');
+    const isLocalPath = account.avatar.startsWith('file://') || account.avatar.startsWith('./') || account.avatar.startsWith('/');
+    
+    if (!isHttpUrl && !isLocalPath) {
+      renderUrl.value = account.avatar;
+      return;
+    }
+
+    isLoading.value = true;
+    error.value = null;
+
+    try {
+      const render = await getAccountSkinRender(account);
+      renderUrl.value = render;
+    } catch (err) {
+      error.value = err instanceof Error ? err.message : 'Failed to load skin render';
+      console.error('[useSkinRender] Failed to load skin render:', err);
+      // В случае ошибки используем оригинальный URL скина
+      renderUrl.value = account.avatar;
+    } finally {
+      isLoading.value = false;
+    }
+  };
+
+  // Автоматически загружаем рендер при изменении аккаунта или скина
+  watch(
+    () => [account?.avatar, account?.skinSha1],
+    () => {
+      loadRender();
+    },
+    { immediate: true }
+  );
+
+  return {
+    renderUrl: computed(() => renderUrl.value),
+    isLoading: computed(() => isLoading.value),
+    error: computed(() => error.value),
+    reload: loadRender,
+  };
+}
+

package/src/shared/composables/useZlDeepLink.ts

@@ -0,0 +1,178 @@
+import { ref, watch } from 'vue';
+import { useRouter } from 'vue-router';
+import { useUserModel } from '@/models';
+
+type DeepLinkPayload = unknown;
+
+export interface UseZlDeepLinkOptions {
+  protocol?: string;
+  app?: any;
+}
+
+function extractUrlFromValue(value: unknown, protocol: string): string | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const trimmed = value.trim().replace(/^"+|"+$/g, '');
+  const escapedProtocol = protocol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = trimmed.match(new RegExp(`${escapedProtocol}\\S*`, 'i'));
+  if (match) {
+    return match[0];
+  }
+
+  try {
+    const decoded = decodeURIComponent(trimmed);
+    const decodedMatch = decoded.match(new RegExp(`${escapedProtocol}\\S*`, 'i'));
+    return decodedMatch ? decodedMatch[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractUrlFromPayload(payload: DeepLinkPayload, protocol: string): string | null {
+  if (Array.isArray(payload)) {
+    for (const item of payload) {
+      const extracted = extractUrlFromPayload(item, protocol);
+      if (extracted) {
+        return extracted;
+      }
+    }
+    return null;
+  }
+
+  if (payload && typeof payload === 'object') {
+    for (const value of Object.values(payload)) {
+      const extracted = extractUrlFromPayload(value, protocol);
+      if (extracted) {
+        return extracted;
+      }
+    }
+    return null;
+  }
+
+  return extractUrlFromValue(payload, protocol);
+}
+
+function routePathFromUrl(url: string, protocol: string): string {
+  let routePath = url.slice(protocol.length);
+  routePath = routePath.replace(/^\/+/, '');
+
+  if (!routePath) {
+    return '/';
+  }
+
+  if (routePath.startsWith('#/')) {
+    return routePath.slice(1);
+  }
+
+  if (routePath.startsWith('/')) {
+    return routePath;
+  }
+
+  return `/${routePath}`;
+}
+
+function focusAppWindow(): void {
+  try {
+    const win = (window as any)?.nw?.Window?.get?.();
+    if (!win) {
+      return;
+    }
+
+    win.restore();
+    if (typeof win.maximize === 'function') {
+      win.maximize();
+    }
+    win.show();
+    win.focus();
+  } catch (error) {
+    console.warn('[protocol] Failed to focus app window:', error);
+  }
+}
+
+function registerWindowsProtocol(protocol: string, app: any): void {
+  if (import.meta.env.DEV || process.platform !== 'win32' || !app?.argv) {
+    return;
+  }
+
+  try {
+    const childProcess = (window as any).nw.require('child_process');
+    const protocolName = protocol.replace('://', '');
+    const baseKey = `HKCU\\Software\\Classes\\${protocolName}`;
+    const commandValue = `"${process.execPath}" "%1"`;
+
+    const runRegAdd = (args: string[]) => {
+      const result = childProcess.spawnSync('reg', ['add', ...args], {
+        windowsHide: true,
+      });
+
+      if (result.status !== 0) {
+        const errorText = result.stderr?.toString?.() || `reg exited with code ${result.status}`;
+        throw new Error(errorText);
+      }
+    };
+
+    runRegAdd([baseKey, '/ve', '/d', `URL:${protocolName} Protocol`, '/f']);
+    runRegAdd([baseKey, '/v', 'URL Protocol', '/d', '', '/f']);
+    runRegAdd([`${baseKey}\\shell\\open\\command`, '/ve', '/d', commandValue, '/f']);
+
+    console.log('[protocol] Registered in Windows registry:', commandValue);
+  } catch (error) {
+    console.warn('[protocol] Failed to register Windows protocol:', error);
+  }
+}
+
+export function useZlDeepLink(options: UseZlDeepLinkOptions = {}) {
+  const router = useRouter();
+  const userModel = useUserModel();
+  const protocol = (options.protocol ?? 'zl://').toLowerCase();
+  const app = options.app ?? (window as any)?.nw?.App ?? null;
+  const pendingUrl = ref<string | null>(null);
+
+  registerWindowsProtocol(protocol, app);
+
+  async function flushIfAuthorized() {
+    if (!pendingUrl.value || !userModel.isAuthenticated.value) {
+      return;
+    }
+
+    const url = pendingUrl.value;
+    const routePath = routePathFromUrl(url, protocol);
+    pendingUrl.value = null;
+    focusAppWindow();
+    await router.isReady();
+    await router.push(routePath);
+  }
+
+  async function acceptPayload(payload: DeepLinkPayload, source: string) {
+    const extracted = extractUrlFromPayload(payload, protocol);
+    if (!extracted) {
+      return;
+    }
+
+    pendingUrl.value = extracted;
+    console.log(`[protocol] [${source}]`, extracted);
+    await flushIfAuthorized();
+  }
+
+  watch(
+    () => userModel.isAuthenticated.value,
+    async (isAuthenticated) => {
+      if (!isAuthenticated) {
+        return;
+      }
+      await flushIfAuthorized();
+    },
+    { immediate: true }
+  );
+
+  if (app?.onOpen?.addListener) {
+    app.onOpen.addListener((payload: DeepLinkPayload) => {
+      void acceptPayload(payload, 'nw.App.onOpen');
+    });
+  }
+
+  void acceptPayload(app?.argv ?? [], 'nw.App.argv');
+  void acceptPayload(process.argv, 'process.argv');
+}