@lobehub/chat 1.124.4 → 1.126.0

package/src/store/image/slices/generationConfig/action.ts

@@ -9,8 +9,12 @@ import {
 import { StateCreator } from 'zustand/vanilla';
 
 import { aiProviderSelectors, getAiInfraStoreState } from '@/store/aiInfra';
+import { useGlobalStore } from '@/store/global';
+import { useUserStore } from '@/store/user';
+import { authSelectors } from '@/store/user/selectors';
 
 import type { ImageStore } from '../../store';
+import { calculateInitialAspectRatio } from '../../utils/aspectRatio';
 import { adaptSizeToRatio, parseRatio } from '../../utils/size';
 
 export interface GenerationConfigAction {
@@ -34,6 +38,13 @@ export interface GenerationConfigAction {
   setHeight(height: number): void;
   toggleAspectRatioLock(): void;
   setAspectRatio(aspectRatio: string): void;
+
+  // 初始化相关方法
+  initializeImageConfig(
+    isLogin?: boolean,
+    lastSelectedImageModel?: string,
+    lastSelectedImageProvider?: string,
+  ): void;
 }
 
 /**
@@ -43,9 +54,22 @@ export interface GenerationConfigAction {
  */
 export function getModelAndDefaults(model: string, provider: string) {
   const enabledImageModelList = aiProviderSelectors.enabledImageModelList(getAiInfraStoreState());
-  const activeModel = enabledImageModelList
-    .find((providerItem) => providerItem.id === provider)
-    ?.children.find((modelItem) => modelItem.id === model) as unknown as AIImageModelCard;
+
+  const providerItem = enabledImageModelList.find((providerItem) => providerItem.id === provider);
+  if (!providerItem) {
+    throw new Error(
+      `Provider "${provider}" not found in enabled image provider list. Available providers: ${enabledImageModelList.map((p) => p.id).join(', ')}`,
+    );
+  }
+
+  const activeModel = providerItem.children.find(
+    (modelItem) => modelItem.id === model,
+  ) as unknown as AIImageModelCard;
+  if (!activeModel) {
+    throw new Error(
+      `Model "${model}" not found in provider "${provider}". Available models: ${providerItem.children.map((m) => m.id).join(', ')}`,
+    );
+  }
 
   const parametersSchema = activeModel.parameters as ModelParamsSchema;
   const defaultValues = extractDefaultValues(parametersSchema);
@@ -53,6 +77,22 @@ export function getModelAndDefaults(model: string, provider: string) {
   return { defaultValues, activeModel, parametersSchema };
 }
 
+/**
+ * @internal Helper
+ * Internal utility to derive initial config for a given provider/model.
+ * Not exported; tests should cover through public actions.
+ */
+function prepareModelConfigState(model: string, provider: string) {
+  const { defaultValues, parametersSchema } = getModelAndDefaults(model, provider);
+  const initialActiveRatio = calculateInitialAspectRatio(parametersSchema, defaultValues);
+
+  return {
+    defaultValues,
+    parametersSchema,
+    initialActiveRatio,
+  };
+}
+
 export const createGenerationConfigSlice: StateCreator<
   ImageStore,
   [['zustand/devtools', never]],
@@ -237,38 +277,32 @@ export const createGenerationConfigSlice: StateCreator<
   },
 
   setModelAndProviderOnSelect: (model, provider) => {
-    const { defaultValues, activeModel } = getModelAndDefaults(model, provider);
-    const parametersSchema = activeModel.parameters;
-
-    let initialActiveRatio: string | null = null;
-
-    // 如果模型没有原生比例或尺寸参数，但有宽高，则启用虚拟比例控制
-    if (
-      !parametersSchema?.aspectRatio &&
-      !parametersSchema?.size &&
-      parametersSchema?.width &&
-      parametersSchema?.height
-    ) {
-      const { width, height } = defaultValues;
-      if (typeof width === 'number' && typeof height === 'number' && width > 0 && height > 0) {
-        initialActiveRatio = `${width}:${height}`;
-      } else {
-        initialActiveRatio = '1:1';
-      }
-    }
+    const { defaultValues, parametersSchema, initialActiveRatio } = prepareModelConfigState(
+      model,
+      provider,
+    );
 
     set(
       {
         model,
         provider,
         parameters: defaultValues,
-        parametersSchema: parametersSchema,
+        parametersSchema,
         isAspectRatioLocked: false,
         activeAspectRatio: initialActiveRatio,
       },
       false,
       `setModelAndProviderOnSelect/${model}/${provider}`,
     );
+
+    // 仅在登录用户下记忆上次选择，保持与恢复策略一致
+    const isLogin = authSelectors.isLogin(useUserStore.getState());
+    if (isLogin) {
+      useGlobalStore.getState().updateSystemStatus({
+        lastSelectedImageModel: model,
+        lastSelectedImageProvider: provider,
+      });
+    }
   },
 
   setImageNum: (imageNum) => {
@@ -292,4 +326,47 @@ export const createGenerationConfigSlice: StateCreator<
   reuseSeed: (seed: number) => {
     set((state) => ({ parameters: { ...state.parameters, seed } }), false, `reuseSeed/${seed}`);
   },
+
+  initializeImageConfig: (isLogin, lastSelectedImageModel, lastSelectedImageProvider) => {
+    // If no parameters are passed, get from store (backward compatibility)
+    let actualIsLogin = isLogin;
+    let actualLastSelectedImageModel = lastSelectedImageModel;
+    let actualLastSelectedImageProvider = lastSelectedImageProvider;
+
+    if (typeof isLogin === 'undefined') {
+      const globalStatus = useGlobalStore.getState().status;
+      actualIsLogin = authSelectors.isLogin(useUserStore.getState());
+      actualLastSelectedImageModel = globalStatus.lastSelectedImageModel;
+      actualLastSelectedImageProvider = globalStatus.lastSelectedImageProvider;
+    }
+
+    if (actualIsLogin && actualLastSelectedImageModel && actualLastSelectedImageProvider) {
+      try {
+        const { defaultValues, parametersSchema, initialActiveRatio } = prepareModelConfigState(
+          actualLastSelectedImageModel,
+          actualLastSelectedImageProvider,
+        );
+
+        set(
+          {
+            model: actualLastSelectedImageModel,
+            provider: actualLastSelectedImageProvider,
+            parameters: defaultValues,
+            parametersSchema,
+            isAspectRatioLocked: false,
+            activeAspectRatio: initialActiveRatio,
+            isInit: true,
+          },
+          false,
+          `initializeImageConfig/${actualLastSelectedImageModel}/${actualLastSelectedImageProvider}`,
+        );
+      } catch {
+        // If restoration fails, simply mark as initialized to use default configuration
+        set({ isInit: true }, false, 'initializeImageConfig/fallback');
+      }
+    } else {
+      // No remembered model, directly mark as initialized (use default values)
+      set({ isInit: true }, false, 'initializeImageConfig/default');
+    }
+  },
 });

package/src/store/image/slices/generationConfig/initialState.ts

@@ -21,6 +21,11 @@ export interface GenerationConfigState {
 
   isAspectRatioLocked: boolean;
   activeAspectRatio: string | null; // string - 虚拟比例; null - 原生比例
+
+  /**
+   * 标记配置是否已初始化（包括从记忆中恢复）
+   */
+  isInit: boolean;
 }
 
 export const DEFAULT_IMAGE_GENERATION_PARAMETERS: RuntimeImageGenParams =
@@ -34,4 +39,5 @@ export const initialGenerationConfigState: GenerationConfigState = {
   parametersSchema: gptImage1ParamsSchema,
   isAspectRatioLocked: false,
   activeAspectRatio: null,
+  isInit: false,
 };

package/src/store/image/utils/aspectRatio.test.ts

@@ -0,0 +1,148 @@
+import { ModelParamsSchema } from 'model-bank';
+import { describe, expect, it } from 'vitest';
+
+import { calculateInitialAspectRatio, supportsVirtualAspectRatio } from './aspectRatio';
+
+// Test data fixtures
+const createBaseSchema = (overrides: Partial<ModelParamsSchema> = {}): ModelParamsSchema => ({
+  prompt: { default: '' },
+  ...overrides,
+});
+
+const createDimensionSchema = (overrides: Partial<ModelParamsSchema> = {}): ModelParamsSchema =>
+  createBaseSchema({
+    width: { default: 512, min: 256, max: 2048 },
+    height: { default: 512, min: 256, max: 2048 },
+    ...overrides,
+  });
+
+const createDefaultValues = (values: Record<string, any> = {}) => ({
+  prompt: '',
+  ...values,
+});
+
+describe('aspectRatio utils', () => {
+  describe('calculateInitialAspectRatio', () => {
+    it('should return null when native aspect controls are present', () => {
+      // Models with native aspectRatio parameter
+      const aspectRatioSchema = createBaseSchema({
+        aspectRatio: { default: '1:1', enum: ['1:1', '16:9', '4:3'] },
+      });
+      const aspectRatioValues = createDefaultValues({ aspectRatio: '1:1' });
+
+      expect(calculateInitialAspectRatio(aspectRatioSchema, aspectRatioValues)).toBeNull();
+
+      // Models with native size parameter
+      const sizeSchema = createBaseSchema({
+        size: { default: '1024x1024', enum: ['512x512', '1024x1024', '1536x1536'] },
+      });
+      const sizeValues = createDefaultValues({ size: '1024x1024' });
+
+      expect(calculateInitialAspectRatio(sizeSchema, sizeValues)).toBeNull();
+    });
+
+    it('should return null when width or height parameters are missing', () => {
+      const schemaWithoutWidth = createBaseSchema({
+        height: { default: 512, min: 256, max: 2048 },
+      });
+      const valuesWithoutWidth = createDefaultValues({ height: 512 });
+
+      expect(calculateInitialAspectRatio(schemaWithoutWidth, valuesWithoutWidth)).toBeNull();
+
+      const schemaWithoutHeight = createBaseSchema({
+        width: { default: 512, min: 256, max: 2048 },
+      });
+      const valuesWithoutHeight = createDefaultValues({ width: 512 });
+
+      expect(calculateInitialAspectRatio(schemaWithoutHeight, valuesWithoutHeight)).toBeNull();
+    });
+
+    it('should calculate aspect ratio from width and height values', () => {
+      const schema = createDimensionSchema({
+        width: { default: 1024, min: 256, max: 2048 },
+        height: { default: 768, min: 256, max: 2048 },
+      });
+      const values = createDefaultValues({ width: 1024, height: 768 });
+
+      expect(calculateInitialAspectRatio(schema, values)).toBe('1024:768');
+    });
+
+    it('should handle square dimensions correctly', () => {
+      const schema = createDimensionSchema();
+      const values = createDefaultValues({ width: 512, height: 512 });
+
+      expect(calculateInitialAspectRatio(schema, values)).toBe('512:512');
+    });
+
+    it('should return fallback ratio for invalid dimension values', () => {
+      const schema = createDimensionSchema();
+
+      // Invalid values should fallback to 1:1
+      const testCases = [
+        { width: NaN, height: NaN },
+        { width: 0, height: 512 },
+        { width: -512, height: 512 },
+        { height: 512 }, // missing width
+        { width: 512 }, // missing height
+      ];
+
+      testCases.forEach((testCase) => {
+        const values = createDefaultValues(testCase);
+        expect(calculateInitialAspectRatio(schema, values)).toBe('1:1');
+      });
+    });
+  });
+
+  describe('supportsVirtualAspectRatio', () => {
+    it('should return true for models with width/height but no native aspect controls', () => {
+      const schema = createDimensionSchema();
+
+      expect(supportsVirtualAspectRatio(schema)).toBe(true);
+    });
+
+    it('should return false when native aspect controls are present', () => {
+      // Schema with native aspectRatio parameter
+      const aspectRatioSchema = createDimensionSchema({
+        aspectRatio: { default: '1:1', enum: ['1:1', '16:9', '4:3'] },
+      });
+
+      expect(supportsVirtualAspectRatio(aspectRatioSchema)).toBe(false);
+
+      // Schema with native size parameter
+      const sizeSchema = createDimensionSchema({
+        size: { default: '1024x1024', enum: ['512x512', '1024x1024', '1536x1536'] },
+      });
+
+      expect(supportsVirtualAspectRatio(sizeSchema)).toBe(false);
+
+      // Schema with both aspectRatio and size parameters
+      const bothSchema = createDimensionSchema({
+        aspectRatio: { default: '1:1', enum: ['1:1', '16:9', '4:3'] },
+        size: { default: '1024x1024', enum: ['512x512', '1024x1024', '1536x1536'] },
+      });
+
+      expect(supportsVirtualAspectRatio(bothSchema)).toBe(false);
+    });
+
+    it('should return false when required dimension parameters are missing', () => {
+      // Missing width parameter
+      const schemaWithoutWidth = createBaseSchema({
+        height: { default: 512, min: 256, max: 2048 },
+      });
+
+      expect(supportsVirtualAspectRatio(schemaWithoutWidth)).toBe(false);
+
+      // Missing height parameter
+      const schemaWithoutHeight = createBaseSchema({
+        width: { default: 512, min: 256, max: 2048 },
+      });
+
+      expect(supportsVirtualAspectRatio(schemaWithoutHeight)).toBe(false);
+
+      // Missing both width and height parameters
+      const emptySchema = createBaseSchema();
+
+      expect(supportsVirtualAspectRatio(emptySchema)).toBe(false);
+    });
+  });
+});

package/src/store/image/utils/aspectRatio.ts

@@ -0,0 +1,45 @@
+import { ModelParamsSchema } from 'model-bank';
+
+/**
+ * Calculate initial aspect ratio for image generation models
+ * @param parametersSchema - The model's parameter schema
+ * @param defaultValues - Default parameter values from the model
+ * @returns Initial aspect ratio string or null if not applicable
+ */
+export const calculateInitialAspectRatio = (
+  parametersSchema: ModelParamsSchema,
+  defaultValues: Record<string, any>,
+): string | null => {
+  // If model has native aspect ratio or size parameters, don't use virtual ratio control
+  if (parametersSchema?.aspectRatio || parametersSchema?.size) {
+    return null;
+  }
+
+  // If model doesn't have width/height parameters, no virtual ratio needed
+  if (!parametersSchema?.width || !parametersSchema?.height) {
+    return null;
+  }
+
+  const { width, height } = defaultValues;
+
+  // Ensure we have valid numeric width and height values
+  if (typeof width === 'number' && typeof height === 'number' && width > 0 && height > 0) {
+    return `${width}:${height}`;
+  }
+
+  // Default fallback ratio
+  return '1:1';
+};
+
+/**
+ * Check if a model supports virtual aspect ratio control
+ * Virtual aspect ratio is enabled when model has width/height but no native aspect ratio/size controls
+ */
+export const supportsVirtualAspectRatio = (parametersSchema: ModelParamsSchema): boolean => {
+  return (
+    !parametersSchema?.aspectRatio &&
+    !parametersSchema?.size &&
+    !!parametersSchema?.width &&
+    !!parametersSchema?.height
+  );
+};