@rynt/sdk 0.9.53

package/src/shared/composables/registrySlot/registry-slot-utils.ts

@@ -0,0 +1,25 @@
+import { CORE_LOADER_REGISTRY_ID } from '../../../extensions/registries/builtins/loader';
+import { resolveRegistrySlot } from '../../../extensions/registries/registry-slot';
+
+export { CORE_LOADER_REGISTRY_ID };
+
+/** Есть ли запись `(registryId, key)` в local store. */
+export function isRegistrySlotMissing(
+  registryId: string,
+  key: string | undefined | null,
+): boolean {
+  if (!key?.trim()) {
+    return false;
+  }
+  return resolveRegistrySlot(registryId, key).status === 'missing';
+}
+
+/** Загрузчик из манифеста не зарегистрирован (`vanilla` всегда доступен). */
+export function isCoreLoaderSlotMissing(
+  loaderId: string | undefined | null,
+): boolean {
+  if (!loaderId || loaderId === 'vanilla') {
+    return false;
+  }
+  return isRegistrySlotMissing(CORE_LOADER_REGISTRY_ID, loaderId);
+}

package/src/shared/composables/registrySlot/useRegistrySlotMissing.ts

@@ -0,0 +1,35 @@
+import { computed, type MaybeRefOrGetter, toValue } from 'vue';
+
+import { extensionRegistriesRevision } from '../../../extensions/registries/store';
+import {
+  CORE_LOADER_REGISTRY_ID,
+  isCoreLoaderSlotMissing,
+  isRegistrySlotMissing,
+} from './registry-slot-utils';
+
+export function useRegistrySlotMissing(
+  registryId: MaybeRefOrGetter<string>,
+  registryKey: MaybeRefOrGetter<string | undefined | null>,
+) {
+  const isMissing = computed(() => {
+    void extensionRegistriesRevision.value;
+    return isRegistrySlotMissing(toValue(registryId), toValue(registryKey));
+  });
+
+  return { isMissing, registryId: computed(() => toValue(registryId)) };
+}
+
+export function useCoreLoaderSlotMissing(
+  loaderId: MaybeRefOrGetter<string | undefined | null>,
+) {
+  const isMissing = computed(() => {
+    void extensionRegistriesRevision.value;
+    return isCoreLoaderSlotMissing(toValue(loaderId));
+  });
+
+  return {
+    isMissing,
+    registryId: CORE_LOADER_REGISTRY_ID,
+    loaderKey: computed(() => toValue(loaderId) ?? ''),
+  };
+}

package/src/shared/composables/resourcePacksEditor/resourcePacksEditor.ts

@@ -0,0 +1,448 @@
+import { defineStore } from '../../definitions/defineStore';
+import { computed, ref, watch, type Ref } from 'vue';
+import { debounce } from 'lodash-es';
+import type { BuildVersionManifest, ResourcePack } 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,
+  listModMarketplaceProviders,
+} from '../../mods/mod-marketplace-registry';
+import {
+  scanLocalResourcePacks,
+  toggleResourcePackDisabled,
+  deleteLocalResourcePack,
+} from '../../utils/local-mods';
+
+/** Вкладки: `all` + id зарегистрированных провайдеров. */
+export type ResourcePacksEditorMarketplaceTab = string;
+
+export const useResourcePacksEditorModel = defineStore(
+  (_manifestRef: Ref<BuildVersionManifest | null>) => {
+    // Manifest ref - получаем напрямую при создании store
+    const manifest = _manifestRef;
+
+    const searchQuery = ref('');
+    const marketplaceTab = ref<ResourcePacksEditorMarketplaceTab>('all');
+
+    const marketplaceSearchState = createMarketplaceEditorSearchState();
+    const { isSearching, searchError, marketplaceBrowseStarted } =
+      marketplaceSearchState;
+
+    const marketplaceSearch = createMarketplaceEditorSearch(
+      {
+        manifest,
+        searchQuery,
+        marketplaceTab,
+        ...marketplaceSearchState,
+      },
+      {
+        projectType: 'resourcepack',
+        logTag: 'resourcePacksEditor',
+      },
+    );
+
+    const selectedResourcePackDetails = ref<ProjectDetails | null>(null);
+    const isLoadingResourcePackDetails = ref(false);
+    const resourcePackDetailsError = ref<string | null>(null);
+
+    // Store original manifest for comparing with local resource packs
+    const originalManifest = ref<BuildVersionManifest | null>(null);
+
+    // Local resource packs (not in manifest)
+    const localResourcePacks = ref<ResourcePack[]>([]);
+
+    const installedResourcePacks = computed<ResourcePack[]>(
+      () => (manifest.value?.resourcePacks ?? []) as ResourcePack[],
+    );
+
+    // All resource packs including local ones
+    const allResourcePacks = computed<ResourcePack[]>(() => [
+      ...installedResourcePacks.value,
+      ...localResourcePacks.value,
+    ]);
+
+    function isInstalledBySlug(slug: string): boolean {
+      return installedResourcePacks.value.some(
+        (rp) => rp.projectSlug === slug || rp.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: 'resourcepack' as const,
+        minecraftVersion:
+          manifest.value?._meta?.manifest?.minecraftVersion || '',
+        loader: 'vanilla' as const, // Resource packs don't need loader
+      } as const;
+
+      const prov = getModMarketplaceProvider(item.provider);
+      if (!prov) {
+        console.warn(
+          `[resourcePacksEditor] Unknown marketplace provider: ${item.provider}`,
+        );
+        return;
+      }
+      const resourcePack = (await prov.install(
+        item,
+        installCtx,
+      )) as ResourcePack;
+
+      // Check if already installed
+      const isAlreadyInstalled = installedResourcePacks.value.some(
+        (rp) =>
+          rp.projectSlug === resourcePack.projectSlug ||
+          rp.id === resourcePack.id,
+      );
+
+      if (isAlreadyInstalled) {
+        console.warn(
+          `[resourcePacksEditor] Resource pack ${resourcePack.name} is already installed`,
+        );
+        return;
+      }
+
+      // Check compatibility with selected Minecraft version
+      // Resource packs only need Minecraft version check, no loader check
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      if (
+        resourcePack.constraints &&
+        resourcePack.constraints.minecraft !== currentMc
+      ) {
+        // For resource packs, we can still install but warn the user
+        console.warn(
+          `[resourcePacksEditor] Resource pack ${resourcePack.name} is for Minecraft ${resourcePack.constraints.minecraft}, but selected version is ${currentMc}`,
+        );
+      }
+
+      const allResourcePacks = [...installedResourcePacks.value];
+      allResourcePacks.push(resourcePack);
+      manifest.value.resourcePacks = allResourcePacks;
+    }
+
+    function removeInstalled(idOrSlug: string) {
+      if (!manifest.value) return;
+
+      const allResourcePacks = [...installedResourcePacks.value];
+      manifest.value.resourcePacks = allResourcePacks.filter(
+        (rp) => rp.id !== idOrSlug && rp.projectSlug !== idOrSlug,
+      );
+    }
+
+    async function loadResourcePackDetails(item: MarketplaceItem) {
+      isLoadingResourcePackDetails.value = true;
+      resourcePackDetailsError.value = null;
+      try {
+        const prov = getModMarketplaceProvider(item.provider);
+        if (!prov) {
+          throw new Error(`Unknown provider: ${item.provider}`);
+        }
+        const details = await prov.getProjectDetails(item.projectId);
+        selectedResourcePackDetails.value = details;
+      } catch (e) {
+        resourcePackDetailsError.value =
+          e instanceof Error ? e.message : String(e);
+        selectedResourcePackDetails.value = null;
+      } finally {
+        isLoadingResourcePackDetails.value = false;
+      }
+    }
+
+    async function loadInstalledResourcePackDetails(
+      resourcePack: ResourcePack,
+    ) {
+      isLoadingResourcePackDetails.value = true;
+      resourcePackDetailsError.value = null;
+      try {
+        let details: ProjectDetails | null = null;
+        const prov = getModMarketplaceProvider(resourcePack.source);
+        if (prov) {
+          details = await prov.getProjectDetails(resourcePack.id);
+        }
+        if (details) {
+          selectedResourcePackDetails.value = details;
+        } else {
+          selectedResourcePackDetails.value = {
+            provider: resourcePack.source as ProjectDetails['provider'],
+            projectId: resourcePack.id,
+            slug: resourcePack.projectSlug || resourcePack.id,
+            name: resourcePack.name,
+            summary: 'Локальный ресурспак',
+            iconUrl: resourcePack.image || '',
+            downloads: 0,
+          };
+        }
+      } catch (e) {
+        resourcePackDetailsError.value =
+          e instanceof Error ? e.message : String(e);
+        selectedResourcePackDetails.value = null;
+      } finally {
+        isLoadingResourcePackDetails.value = false;
+      }
+    }
+
+    function clearResourcePackDetails() {
+      selectedResourcePackDetails.value = null;
+      resourcePackDetailsError.value = null;
+    }
+
+    /**
+     * Check if a resource pack is compatible with selected Minecraft version
+     */
+    function checkResourcePackCompatibility(resourcePack: ResourcePack): {
+      isValid: boolean;
+      reason?: string;
+    } {
+      if (!resourcePack.constraints) {
+        return { isValid: true };
+      }
+
+      const currentMc = manifest.value?._meta?.manifest?.minecraftVersion || '';
+      const mcMatch = resourcePack.constraints.minecraft === currentMc;
+
+      if (!mcMatch) {
+        return {
+          isValid: false,
+          reason: `Minecraft ${resourcePack.constraints.minecraft} (выбрано: ${currentMc})`,
+        };
+      }
+
+      return { isValid: true };
+    }
+
+    /**
+     * Get compatibility status for all installed resource packs
+     */
+    const resourcePacksCompatibilityStatus = computed(() => {
+      const status = new Map<string, { isValid: boolean; reason?: string }>();
+      const installed = installedResourcePacks.value;
+
+      for (const rp of installed) {
+        const rpKey = rp.id || rp.projectSlug;
+        status.set(rpKey, checkResourcePackCompatibility(rp));
+      }
+
+      return status;
+    });
+
+    const activeSearchResults = computed(() =>
+      marketplaceSearch.getMarketplaceSearchResults(marketplaceTab.value),
+    );
+
+    // Debounced search function
+    let debouncedSearch = debounce(() => {
+      void marketplaceSearch.search(true);
+    }, 500);
+
+    // Store watcher stop function
+    let stopWatcher: (() => void) | null = null;
+
+    // Auto-search when query changes (debounced) - will be recreated in init
+    function setupSearchWatcher() {
+      // Stop existing watcher if any
+      if (stopWatcher) {
+        stopWatcher();
+      }
+
+      // Create new watcher
+      stopWatcher = watch(searchQuery, () => {
+        debouncedSearch();
+      });
+    }
+
+    // Initial setup
+    setupSearchWatcher();
+
+    watch(
+      () => manifest.value?._meta?.manifest?.minecraftVersion,
+      () => {
+        if (!marketplaceBrowseStarted.value) return;
+        void marketplaceSearch.search(true);
+      },
+    );
+
+    /**
+     * Scan for local resource packs
+     */
+    function scanLocalResourcePacksList() {
+      if (!manifest.value?.id) return;
+
+      // Get original manifest from cache (before any edits)
+      const localBuilds = useLocalBuildsModel();
+      const original = localBuilds.getManifestById(manifest.value.id);
+      originalManifest.value = original;
+
+      // Scan local resource packs
+      localResourcePacks.value = scanLocalResourcePacks(
+        manifest.value.id,
+        original,
+      );
+    }
+
+    /**
+     * Toggle disabled state for a resource pack
+     */
+    function toggleResourcePackDisabledState(
+      resourcePack: ResourcePack,
+      disabled: boolean,
+    ) {
+      if (!manifest.value?.id) return false;
+
+      // If it's a local resource pack, toggle the file
+      if (
+        resourcePack.source === 'direct' &&
+        resourcePack.id.startsWith('local-')
+      ) {
+        const success = toggleResourcePackDisabled(
+          manifest.value.id,
+          resourcePack,
+          disabled,
+        );
+        if (success) {
+          // Update the resource pack's disabled state
+          resourcePack.disabled = disabled;
+          // Update file path if needed
+          if (resourcePack.files.length > 0) {
+            const file = resourcePack.files[0];
+            if (disabled) {
+              file.path = file.path.replace(/\.zip$/, '.zip.disabled');
+            } else {
+              file.path = file.path.replace(/\.disabled$/, '');
+            }
+          }
+        }
+        return success;
+      } else {
+        // For manifest resource packs, update the manifest AND rename the file
+        if (!manifest.value.resourcePacks) return false;
+
+        const rpIndex = manifest.value.resourcePacks.findIndex(
+          (rp) => rp.id === resourcePack.id,
+        );
+        if (rpIndex >= 0) {
+          // First, rename the file on disk
+          const success = toggleResourcePackDisabled(
+            manifest.value.id,
+            resourcePack,
+            disabled,
+          );
+          if (!success) return false;
+
+          // Then update the manifest
+          manifest.value.resourcePacks[rpIndex].disabled = disabled;
+          // Also update file paths
+          for (const file of manifest.value.resourcePacks[rpIndex].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;
+    }
+
+    /**
+     * Delete a local resource pack
+     */
+    function deleteLocalResourcePackFile(resourcePack: ResourcePack) {
+      if (!manifest.value?.id) return false;
+
+      if (
+        resourcePack.source === 'direct' &&
+        resourcePack.id.startsWith('local-')
+      ) {
+        const success = deleteLocalResourcePack(
+          manifest.value.id,
+          resourcePack,
+        );
+        if (success) {
+          // Remove from local resource packs list
+          localResourcePacks.value = localResourcePacks.value.filter(
+            (rp) => rp.id !== resourcePack.id,
+          );
+        }
+        return success;
+      }
+      return false;
+    }
+
+    /**
+     * Инициализация редактора (манифест уже передан при создании store)
+     */
+    const init = async (_manifest: BuildVersionManifest | null) => {
+      searchQuery.value = '';
+      searchError.value = null;
+      isSearching.value = false;
+      selectedResourcePackDetails.value = null;
+      resourcePackDetailsError.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);
+
+      // Scan local resource packs after initialization
+      scanLocalResourcePacksList();
+    };
+
+    return {
+      // Resource packs editor API
+      init,
+      marketplaceTab,
+      searchQuery,
+      isSearching,
+      searchError,
+      activeSearchResults,
+      getMarketplaceSearchResults: marketplaceSearch.getMarketplaceSearchResults,
+      isMarketplaceTabSearching: marketplaceSearch.isMarketplaceTabSearching,
+      loadMoreMarketplaceResults: marketplaceSearch.loadMoreMarketplaceResults,
+      canLoadMoreMarketplace: marketplaceSearch.canLoadMoreMarketplace,
+      isLoadingMoreMarketplace: marketplaceSearch.isLoadingMoreMarketplace,
+      marketplaceBrowseStarted,
+      installedResourcePacks,
+      allResourcePacks,
+      localResourcePacks,
+      isInstalledBySlug,
+      selectedResourcePackDetails,
+      isLoadingResourcePackDetails,
+      resourcePackDetailsError,
+      search: marketplaceSearch.search,
+      install,
+      removeInstalled,
+      loadResourcePackDetails,
+      loadInstalledResourcePackDetails,
+      clearResourcePackDetails,
+      resourcePacksCompatibilityStatus,
+      scanLocalResourcePacksList,
+      toggleResourcePackDisabledState,
+      deleteLocalResourcePackFile,
+    };
+  },
+  false,
+);