@rynt/sdk 0.9.53

package/src/shared/composables/buildManifest/buildManifest.ts

@@ -0,0 +1,447 @@
+import { useLauncherModel, useLocalBuildsModel } from '@/models';
+import { useFilesEditorModel } from '../filesEditor/filesEditor';
+import { useModsEditorModel } from '../modsEditor/modsEditor';
+import { useResourcePacksEditorModel } from '../resourcePacksEditor/resourcePacksEditor';
+import { useShaderPacksEditorModel } from '../shaderPacksEditor/shaderPacksEditor';
+import { defineStore } from '../../definitions/defineStore';
+import { initializeBuildManifest } from '../../utils/build-manifest-init';
+import type { BuildVersionManifest } from '../../minecraft-types/build-manifest';
+import type {
+  LoaderGameVersion,
+  LoaderVersionSummary,
+  MinecraftVersion,
+} from '../../minecraft-types/launcher-versions';
+import { computed, ref, watch } from 'vue';
+
+import { extensionRegistriesRevision } from '../../../extensions/registries/store';
+import { isCoreLoaderSlotMissing } from '../../composables/registrySlot/registry-slot-utils';
+
+export const useBuildManifestModel = defineStore(() => {
+  const localBuilds = useLocalBuildsModel();
+  const { saveManifest, buildsIndex, getManifestById } = localBuilds;
+  const { launcher, initialize, versionsManifest } = useLauncherModel();
+
+  /* ============================
+   * STATE
+   * ============================ */
+
+  const manifest = ref<BuildVersionManifest | null>(null);
+
+  const isLoading = ref<boolean>(true);
+
+  const minecraftVersions = ref<MinecraftVersion[]>([]);
+  const isLoadingMinecraftVersions = ref<boolean>(false);
+
+  const loaders = ref<{ id: string; name: string }[]>([]);
+  const isLoadingLoaders = ref<boolean>(false);
+
+  const loaderVersions = ref<LoaderVersionSummary[]>([]);
+  const isLoadingLoaderVersions = ref<boolean>(false);
+
+  // Store original manifest values to preserve loader versions that might be removed from available list
+  const originalManifestValues = ref<{
+    minecraftVersion: string;
+    loader: string;
+    loaderVersion: string;
+  } | null>(null);
+
+  // Track previous loader to detect when it changes
+  const previousLoader = ref<string | null>(null);
+
+  /** В манифесте указан лоадер, которого нет в реестре (расширение выключено и т.п.). */
+  const isManifestLoaderMissing = computed(() => {
+    void extensionRegistriesRevision.value;
+    return isCoreLoaderSlotMissing(manifest.value?._meta?.manifest?.loader);
+  });
+
+  /* ============================
+   * EDITORS - создаем инстансы редакторов
+   * ============================ */
+
+  // Создаем инстансы редакторов, передавая им ref на manifest
+  const modsEditorInstance = useModsEditorModel(manifest);
+  const resourcePacksEditorInstance = useResourcePacksEditorModel(manifest);
+  const shaderPacksEditorInstance = useShaderPacksEditorModel(manifest);
+  const filesEditorInstance = useFilesEditorModel(manifest);
+
+  /* ============================
+   * INIT
+   * ============================ */
+
+  const init = async (_manifest: BuildVersionManifest | null) => {
+    isLoading.value = true;
+
+    try {
+      await initialize();
+      manifest.value = initializeBuildManifest(_manifest, _manifest?.id);
+
+      // Save original manifest values for preserving loader versions
+      if (manifest.value?._meta?.manifest) {
+        originalManifestValues.value = {
+          minecraftVersion:
+            manifest.value._meta.manifest.minecraftVersion || '',
+          loader: manifest.value._meta.manifest.loader || '',
+          loaderVersion: manifest.value._meta.manifest.loaderVersion || '',
+        };
+        // Initialize previous loader to current loader
+        previousLoader.value = manifest.value._meta.manifest.loader || null;
+      }
+
+      await reloadLoaders();
+      await reloadMinecraftVersions();
+      await reloadLoaderVersions();
+
+      // Инициализируем редакторы (манифест уже передан при создании)
+      await Promise.all([
+        modsEditorInstance.init(manifest.value),
+        resourcePacksEditorInstance.init(manifest.value),
+        shaderPacksEditorInstance.init(manifest.value),
+        filesEditorInstance.init(manifest.value),
+      ]);
+
+      isLoading.value = false;
+    } catch (error: any) {
+      isLoading.value = false;
+      throw error;
+    }
+  };
+
+  const reloadLoaders = async () => {
+    isLoadingLoaders.value = true;
+    loaders.value = await launcher.getLoaders();
+    isLoadingLoaders.value = false;
+  };
+
+  const reloadMinecraftVersions = async () => {
+    if (!manifest.value || !versionsManifest.value) {
+      minecraftVersions.value = [];
+      return;
+    }
+
+    isLoadingMinecraftVersions.value = true;
+
+    if (manifest.value._meta.manifest.loader == 'vanilla') {
+      minecraftVersions.value = versionsManifest.value.versions || [];
+    } else if (
+      isCoreLoaderSlotMissing(manifest.value._meta.manifest.loader)
+    ) {
+      minecraftVersions.value = [];
+    } else {
+      const versionIds = (
+        await launcher.getLoaderGameVersions(
+          manifest.value._meta.manifest.loader,
+        )
+      ).map((ver: LoaderGameVersion) => ver.version);
+      minecraftVersions.value = versionsManifest.value?.versions.filter((ver: MinecraftVersion) =>
+        versionIds.includes(ver.id),
+      );
+    }
+
+    isLoadingMinecraftVersions.value = false;
+  };
+  const reloadLoaderVersions = async () => {
+    if (!manifest.value || manifest.value._meta.manifest.loader == 'vanilla') {
+      loaderVersions.value = [];
+      previousLoader.value = null;
+      return;
+    }
+    isLoadingLoaderVersions.value = true;
+
+    const currentLoader = manifest.value._meta.manifest.loader;
+    const currentMinecraftVersion =
+      manifest.value._meta.manifest.minecraftVersion;
+    const loaderChanged =
+      previousLoader.value !== null && previousLoader.value !== currentLoader;
+
+    if (
+      currentLoader &&
+      currentLoader !== 'vanilla' &&
+      isCoreLoaderSlotMissing(currentLoader)
+    ) {
+      loaderVersions.value = [];
+      previousLoader.value = currentLoader;
+      isLoadingLoaderVersions.value = false;
+      return;
+    }
+
+    let availableVersions: LoaderVersionSummary[] = [];
+    // Get available loader versions from launcher
+    if (currentLoader && currentMinecraftVersion) {
+      availableVersions = await launcher.getLoaderVersions(
+        currentLoader,
+        currentMinecraftVersion,
+      );
+    }
+
+    // Check if we should preserve original loader version
+    const isOriginalContext =
+      originalManifestValues.value &&
+      originalManifestValues.value.loader === currentLoader &&
+      originalManifestValues.value.minecraftVersion ===
+        currentMinecraftVersion &&
+      originalManifestValues.value.loader !== '' &&
+      originalManifestValues.value.minecraftVersion !== '' &&
+      originalManifestValues.value.loaderVersion !== '';
+
+    if (isOriginalContext) {
+      // Check if original version is already in the list
+      const originalVersionExists = availableVersions.some(
+        (v) => v.version === originalManifestValues.value!.loaderVersion,
+      );
+
+      // If original version is not in the list, add it to the end
+      if (!originalVersionExists && originalManifestValues.value) {
+        loaderVersions.value = [
+          ...availableVersions,
+          {
+            version: originalManifestValues.value.loaderVersion,
+            stable: true, // Assume stable if it was previously set
+          },
+        ];
+      } else {
+        loaderVersions.value = availableVersions;
+      }
+    } else {
+      loaderVersions.value = availableVersions;
+    }
+
+    // Auto-select loader version
+    if (loaderVersions.value.length > 0 && manifest.value) {
+      const currentLoaderVersion = manifest.value._meta.manifest.loaderVersion;
+      const currentVersionExists = loaderVersions.value.some(
+        (v) => v.version === currentLoaderVersion,
+      );
+
+      // If loader changed, always select first version (ignore current version even if it exists)
+      if (loaderChanged) {
+        manifest.value._meta.manifest.loaderVersion =
+          loaderVersions.value[0].version;
+      }
+      // If current version doesn't exist or is empty, auto-select
+      else if (!currentVersionExists || !currentLoaderVersion) {
+        if (isOriginalContext && originalManifestValues.value) {
+          // Use original version if in original context
+          manifest.value._meta.manifest.loaderVersion =
+            originalManifestValues.value.loaderVersion;
+        } else {
+          // Otherwise use first available version
+          manifest.value._meta.manifest.loaderVersion =
+            loaderVersions.value[0].version;
+        }
+      }
+      // If loader didn't change and current version exists, keep it (don't change)
+    }
+
+    // Update previous loader for next comparison
+    previousLoader.value = currentLoader;
+
+    isLoadingLoaderVersions.value = false;
+  };
+
+  // METHODS
+
+  /**
+   * Delete files of mods/resourcepacks that were removed from manifest
+   */
+  function deleteRemovedModFiles(
+    oldManifest: BuildVersionManifest,
+    newManifest: BuildVersionManifest,
+  ): void {
+    // Check if we're in Node.js environment
+    const isNodeEnv = typeof window !== 'undefined' && (window as any).nw;
+    if (!isNodeEnv) return;
+
+    try {
+      const nw = (window as any).nw;
+      const fs = nw.require('fs');
+      const path = nw.require('path');
+
+      // Get build directory path
+      const buildDirEntry = buildsIndex.value.get(newManifest.id);
+      if (!buildDirEntry) {
+        return; // Build directory entry not found
+      }
+      const buildDir = buildDirEntry.path;
+      if (!fs.existsSync(buildDir)) {
+        return; // Build directory doesn't exist, nothing to delete
+      }
+
+      const deleteFileAndDisabledPair = (relativePath: string, label: string) => {
+        const filePath = path.join(buildDir, relativePath);
+        const fileName = path.basename(relativePath);
+        const fileNameWithoutDisabled = fileName.replace(/\.disabled$/, '');
+        const fileDir = path.dirname(relativePath);
+        const disabledPath = path.join(buildDir, fileDir, `${fileNameWithoutDisabled}.disabled`);
+
+        try {
+          if (fs.existsSync(filePath)) {
+            fs.unlinkSync(filePath);
+            console.log(`[deleteRemovedModFiles] Deleted ${label} file: ${filePath}`);
+          }
+          if (fs.existsSync(disabledPath)) {
+            fs.unlinkSync(disabledPath);
+            console.log(`[deleteRemovedModFiles] Deleted disabled ${label} file: ${disabledPath}`);
+          }
+        } catch (error) {
+          console.warn(`[deleteRemovedModFiles] Failed to delete ${label} file ${filePath}:`, error);
+        }
+      };
+
+      const deleteRemovedAndReplacedFiles = (
+        oldEntries: Array<{ id: string; files?: Array<{ path: string }> }>,
+        newEntries: Array<{ id: string; files?: Array<{ path: string }> }>,
+        label: 'mod' | 'resource pack'
+      ) => {
+        const newById = new Map(newEntries.map((entry) => [entry.id, entry]));
+
+        for (const oldEntry of oldEntries) {
+          const newEntry = newById.get(oldEntry.id);
+          const oldFiles = oldEntry.files || [];
+
+          // Entry removed completely
+          if (!newEntry) {
+            for (const oldFile of oldFiles) {
+              deleteFileAndDisabledPair(oldFile.path, label);
+            }
+            continue;
+          }
+
+          // Entry still exists, but version/file set may have changed
+          const newFilePaths = new Set((newEntry.files || []).map((f) => f.path));
+          for (const oldFile of oldFiles) {
+            if (!newFilePaths.has(oldFile.path)) {
+              deleteFileAndDisabledPair(oldFile.path, label);
+            }
+          }
+        }
+      };
+
+      deleteRemovedAndReplacedFiles(
+        oldManifest.mods || [],
+        newManifest.mods || [],
+        'mod'
+      );
+
+      deleteRemovedAndReplacedFiles(
+        oldManifest.resourcePacks || [],
+        newManifest.resourcePacks || [],
+        'resource pack'
+      );
+    } catch (error) {
+      console.error(
+        '[deleteRemovedModFiles] Error deleting removed mod/resourcepack files:',
+        error,
+      );
+    }
+  }
+
+  const save = async (): Promise<void> => {
+    // Обновляем выбранные файлы в манифесте перед сохранением
+    filesEditorInstance.updateManifestSelectedFiles();
+
+    const { minecraftVersion, loader, loaderVersion } =
+      manifest.value!._meta.manifest;
+
+    if (loader && loaderVersion) {
+      manifest.value!.inheritsFrom = `${loader}::${minecraftVersion}:${loaderVersion}`;
+    } else {
+      manifest.value!.inheritsFrom = minecraftVersion;
+    }
+
+    // Get old manifest from cache before saving
+    const oldManifestId = manifest.value!.id;
+    const oldManifest = getManifestById(oldManifestId);
+    const newManifest = manifest.value!;
+
+    // Логируем для отладки (только в dev режиме)
+    if (process.env.NODE_ENV === 'development') {
+      console.log('[buildManifest.save] Сохраняем манифест:', {
+        id: newManifest.id,
+        minecraftVersion: newManifest._meta?.manifest?.minecraftVersion,
+        loader: newManifest._meta?.manifest?.loader,
+        loaderVersion: newManifest._meta?.manifest?.loaderVersion,
+        modsCount: newManifest.mods?.length || 0,
+        inheritsFrom: newManifest.inheritsFrom,
+      });
+    }
+
+    // Save manifest and get new ID (if it was generated)
+    const savedId = saveManifest(newManifest);
+
+    if (!savedId) {
+      throw new Error('Не удалось сохранить манифест');
+    }
+
+    // Если ID изменился (например, было '_new', стало реальный ID), обновляем manifest.value.id
+    if (savedId !== oldManifestId && manifest.value) {
+      manifest.value.id = savedId;
+    }
+
+    // Delete files of removed mods and resource packs
+    if (oldManifest && manifest.value) {
+      deleteRemovedModFiles(oldManifest, manifest.value);
+    }
+  };
+
+  // WATCHERS
+
+  watch(
+    () => manifest.value?._meta.manifest.loader,
+    async () => {
+      // Clear loader version when loader changes to trigger auto-selection
+      if (
+        manifest.value &&
+        previousLoader.value !== null &&
+        previousLoader.value !== manifest.value._meta.manifest.loader
+      ) {
+        manifest.value._meta.manifest.loaderVersion = '';
+      }
+      await reloadMinecraftVersions();
+      await reloadLoaderVersions();
+    },
+  );
+
+  watch(
+    () => manifest.value?._meta.manifest.minecraftVersion,
+    async () => {
+      await reloadLoaderVersions();
+      // Auto-selection is handled in reloadLoaderVersions, no need to clear here
+    },
+  );
+
+  watch(
+    () => extensionRegistriesRevision.value,
+    async () => {
+      if (!manifest.value) {
+        return;
+      }
+      await reloadLoaders();
+      await reloadMinecraftVersions();
+      await reloadLoaderVersions();
+    },
+  );
+
+  return {
+    // State
+    manifest,
+    isManifestLoaderMissing,
+    isLoading,
+    loaders,
+    isLoadingLoaders,
+    minecraftVersions,
+    isLoadingMinecraftVersions,
+    loaderVersions,
+    isLoadingLoaderVersions,
+    // Methods
+    init,
+    save,
+    reloadLoaders,
+    reloadMinecraftVersions,
+    reloadLoaderVersions,
+    // Editors
+    modsEditor: modsEditorInstance,
+    resourcePacksEditor: resourcePacksEditorInstance,
+    shaderPacksEditor: shaderPacksEditorInstance,
+    filesEditor: filesEditorInstance,
+  };
+}, false);