@qy_better_lib/hooks 0.1.9 → 0.2.0

package/__tests__/use-chart/index.test.ts

@@ -0,0 +1,287 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_chart } from '../../src/use-chart';
+
+// 模拟DOM环境
+global.document = {
+  querySelector: vi.fn(),
+} as any;
+
+// 模拟@qy_better_lib/core的ECharts相关函数
+vi.mock('@qy_better_lib/core', () => {
+  const mockInitChart = vi.fn().mockResolvedValue({ id: 'mock-chart' });
+  const mockDestroyChart = vi.fn();
+  const mockUpdateChart = vi.fn();
+  const mockResizeChart = vi.fn();
+  const mockMakeChartResponsive = vi.fn().mockReturnValue(() => {});
+  const mockMergeChartOptions = vi.fn((defaultOption, customOption) => ({ ...defaultOption, ...customOption }));
+  const mockGenerateChartColors = vi.fn().mockReturnValue(['#ff0000', '#00ff00', '#0000ff']);
+  const mockGetChartGradientColor = vi.fn().mockReturnValue({ type: 'linear', x: 0, y: 0, x2: 0, y2: 1, colorStops: [] });
+  const mockExportChartImage = vi.fn().mockReturnValue('data:image/png;base64,mock');
+  const mockAddChartListener = vi.fn();
+  const mockRemoveChartListener = vi.fn();
+  const mockAutoSize = vi.fn().mockImplementation((size) => size);
+  
+  return {
+    __esModule: true,
+    deep_assign: (target: object, ...sources: any) => Object.assign(target, ...sources),
+    deep_clone: (obj: any) => JSON.parse(JSON.stringify(obj)),
+    init_chart: mockInitChart,
+    destroy_chart: mockDestroyChart,
+    update_chart: mockUpdateChart,
+    resize_chart: mockResizeChart,
+    make_chart_responsive: mockMakeChartResponsive,
+    merge_chart_options: mockMergeChartOptions,
+    generate_chart_colors: mockGenerateChartColors,
+    get_chart_gradient_color: mockGetChartGradientColor,
+    export_chart_image: mockExportChartImage,
+    add_chart_listener: mockAddChartListener,
+    remove_chart_listener: mockRemoveChartListener,
+    auto_size: mockAutoSize,
+  };
+});
+
+describe('use_chart', () => {
+  let mockChart: any;
+  let mockCleanup: any;
+
+  beforeEach(() => {
+    // 重置所有模拟
+    vi.clearAllMocks();
+    
+    // 模拟DOM元素
+    mockChart = { id: 'mock-chart' };
+    mockCleanup = vi.fn();
+    
+    // 模拟document.querySelector返回一个DOM元素
+    (document.querySelector as vi.Mock).mockReturnValue({ id: 'chart-container' });
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it('should initialize with default options', () => {
+    const chartInstance = use_chart();
+    
+    expect(chartInstance).toHaveProperty('render_chart');
+    expect(chartInstance).toHaveProperty('get_chart');
+    expect(chartInstance).toHaveProperty('update_chart');
+    expect(chartInstance).toHaveProperty('remove_chart');
+    expect(chartInstance).toHaveProperty('resize_chart');
+    expect(chartInstance).toHaveProperty('destroy_all_charts');
+    expect(chartInstance).toHaveProperty('generate_chart_colors');
+    expect(chartInstance).toHaveProperty('get_chart_gradient_color');
+    expect(chartInstance).toHaveProperty('export_chart_image');
+    expect(chartInstance).toHaveProperty('add_chart_listener');
+    expect(chartInstance).toHaveProperty('remove_chart_listener');
+    expect(chartInstance).toHaveProperty('auto_size');
+  });
+
+  it('should render chart successfully', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    const result = await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    expect(result).toBeDefined();
+  });
+
+  it('should return null when DOM element not found', async () => {
+    // 模拟document.querySelector返回null
+    (document.querySelector as vi.Mock).mockReturnValue(null);
+    
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    const result = await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    expect(result).toBeNull();
+  });
+
+  it('should use dark theme when specified', async () => {
+    const chartInstance = use_chart({ default_theme: 'dark' });
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    const result = await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    expect(result).toBeDefined();
+  });
+
+  it('should get chart instance', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 先渲染图表
+    await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    // 获取图表实例
+    const result = chartInstance.get_chart('#chart-container');
+    
+    expect(result).toBeDefined();
+  });
+
+  it('should return undefined when getting non-existent chart', async () => {
+    const chartInstance = use_chart();
+    
+    // 尝试获取不存在的图表
+    const result = chartInstance.get_chart('#non-existent-container');
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should update chart successfully', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 先渲染图表
+    await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    // 更新图表
+    const updateConfig = {
+      series: [{ type: 'bar', data: [4, 5, 6] }],
+    };
+    const result = chartInstance.update_chart('#chart-container', updateConfig);
+    
+    expect(result).toBe(true);
+  });
+
+  it('should return false when updating non-existent chart', async () => {
+    const chartInstance = use_chart();
+    const updateConfig = {
+      series: [{ type: 'bar', data: [4, 5, 6] }],
+    };
+    
+    // 尝试更新不存在的图表
+    const result = chartInstance.update_chart('#non-existent-container', updateConfig);
+    
+    expect(result).toBe(false);
+  });
+
+  it('should remove chart successfully', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 先渲染图表
+    await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    // 移除图表
+    const result = chartInstance.remove_chart('#chart-container');
+    
+    expect(result).toBe(true);
+  });
+
+  it('should return false when removing non-existent chart', async () => {
+    const chartInstance = use_chart();
+    
+    // 尝试移除不存在的图表
+    const result = chartInstance.remove_chart('#non-existent-container');
+    
+    expect(result).toBe(false);
+  });
+
+  it('should resize chart successfully', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 先渲染图表
+    await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    // 调整图表大小
+    const result = chartInstance.resize_chart('#chart-container');
+    
+    expect(result).toBe(true);
+  });
+
+  it('should return false when resizing non-existent chart', async () => {
+    const chartInstance = use_chart();
+    
+    // 尝试调整不存在的图表大小
+    const result = chartInstance.resize_chart('#non-existent-container');
+    
+    expect(result).toBe(false);
+  });
+
+  it('should destroy all charts', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 渲染多个图表
+    await chartInstance.render_chart(chartConfig, '#chart-container-1');
+    await chartInstance.render_chart(chartConfig, '#chart-container-2');
+    
+    // 销毁所有图表
+    chartInstance.destroy_all_charts();
+    
+    // 验证所有图表已被销毁
+    const result1 = chartInstance.get_chart('#chart-container-1');
+    const result2 = chartInstance.get_chart('#chart-container-2');
+    expect(result1).toBeUndefined();
+    expect(result2).toBeUndefined();
+  });
+
+  it('should export chart image successfully', async () => {
+    const chartInstance = use_chart();
+    const chartConfig = {
+      title: { text: 'Test Chart' },
+      series: [{ type: 'bar', data: [1, 2, 3] }],
+    };
+    
+    // 先渲染图表
+    await chartInstance.render_chart(chartConfig, '#chart-container');
+    
+    // 导出图表
+    const result = chartInstance.export_chart_image('#chart-container');
+    
+    expect(result).toBeDefined();
+  });
+
+  it('should return null when exporting non-existent chart', async () => {
+    const chartInstance = use_chart();
+    
+    // 尝试导出不存在的图表
+    const result = chartInstance.export_chart_image('#non-existent-container');
+    
+    expect(result).toBeNull();
+  });
+
+  it('should call utility functions', () => {
+    const chartInstance = use_chart();
+    
+    // 测试generate_chart_colors
+    const colors = chartInstance.generate_chart_colors(3);
+    expect(colors).toBeDefined();
+    expect(Array.isArray(colors)).toBe(true);
+    
+    // 测试get_chart_gradient_color
+    const gradient = chartInstance.get_chart_gradient_color('v', '#ff0000', '#0000ff');
+    expect(gradient).toBeDefined();
+    
+    // 测试auto_size
+    const size = chartInstance.auto_size(14);
+    expect(typeof size).toBe('number');
+  });
+});

package/__tests__/use-emit/index.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_emit } from '../../src/use-emit';
+import { onMounted, onUnmounted } from 'vue';
+
+// 模拟vue的生命周期钩子
+vi.mock('vue', () => ({
+  onMounted: vi.fn(),
+  onUnmounted: vi.fn(),
+}));
+
+// 模拟mitt库
+vi.mock('mitt', () => {
+  const listeners = new Map();
+  
+  return {
+    default: vi.fn(() => ({
+      on: vi.fn((type: string, handler: Function) => {
+        if (!listeners.has(type)) {
+          listeners.set(type, []);
+        }
+        listeners.get(type).push(handler);
+      }),
+      off: vi.fn((type: string, handler: Function) => {
+        if (listeners.has(type)) {
+          const handlers = listeners.get(type);
+          const index = handlers.indexOf(handler);
+          if (index > -1) {
+            handlers.splice(index, 1);
+          }
+        }
+      }),
+      emit: vi.fn((type: string, ...args: any[]) => {
+        if (listeners.has(type)) {
+          const handlers = listeners.get(type);
+          let lastResult: any;
+          handlers.forEach((handler: Function) => {
+            lastResult = handler(...args);
+          });
+          return lastResult;
+        }
+        return undefined;
+      }),
+      all: listeners,
+    })),
+  };
+});
+
+describe('use_emit', () => {
+  let mockOnMountedCallback: Function;
+  let mockOnUnmountedCallback: Function;
+
+  beforeEach(() => {
+    // 重置所有模拟
+    vi.clearAllMocks();
+    
+    // 捕获生命周期钩子的回调
+    mockOnMountedCallback = vi.fn();
+    mockOnUnmountedCallback = vi.fn();
+    
+    (onMounted as vi.Mock).mockImplementation((callback: Function) => {
+      mockOnMountedCallback = callback;
+    });
+    
+    (onUnmounted as vi.Mock).mockImplementation((callback: Function) => {
+      mockOnUnmountedCallback = callback;
+    });
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it('should initialize and return emitter object', () => {
+    const { emitter } = use_emit();
+    
+    expect(emitter).toBeDefined();
+    expect(typeof emitter.on).toBe('function');
+    expect(typeof emitter.off).toBe('function');
+    expect(typeof emitter.emit).toBe('function');
+    expect(typeof emitter.emitAsync).toBe('function');
+  });
+
+  it('should register event listeners on mount', () => {
+    const mockHandler = vi.fn();
+    const eventList = [
+      { key: 'test-event', value: mockHandler },
+    ];
+    
+    const { emitter } = use_emit(eventList);
+    
+    // 触发mounted钩子
+    mockOnMountedCallback();
+    
+    // 验证emitter对象存在
+    expect(emitter).toBeDefined();
+  });
+
+  it('should remove event listeners on unmount', () => {
+    const mockHandler = vi.fn();
+    const eventList = [
+      { key: 'test-event', value: mockHandler },
+    ];
+    
+    const { emitter } = use_emit(eventList);
+    
+    // 触发mounted钩子
+    mockOnMountedCallback();
+    
+    // 触发unmounted钩子
+    mockOnUnmountedCallback();
+    
+    // 验证emitter对象存在
+    expect(emitter).toBeDefined();
+  });
+
+  it('should emit events and return last handler result', () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockReturnValue('result1');
+    const mockHandler2 = vi.fn().mockReturnValue('result2');
+    
+    // 注册事件监听器
+    emitter.on('test-event', mockHandler1);
+    emitter.on('test-event', mockHandler2);
+    
+    // 触发事件
+    const result = emitter.emit('test-event', { data: 'test' });
+    
+    // 验证结果
+    expect(result).toBe('result2'); // 应该返回最后一个处理器的结果
+    expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' });
+  });
+
+  it('should return undefined when no listeners for event', () => {
+    const { emitter } = use_emit();
+    
+    // 触发不存在的事件
+    const result = emitter.emit('non-existent-event', { data: 'test' });
+    
+    expect(result).toBeUndefined();
+  });
+
+  it('should emit async events and return all handler results', async () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockResolvedValue('async-result1');
+    const mockHandler2 = vi.fn().mockReturnValue('sync-result2');
+    
+    // 注册事件监听器
+    emitter.on('async-test-event', mockHandler1);
+    emitter.on('async-test-event', mockHandler2);
+    
+    // 触发异步事件
+    const results = await emitter.emitAsync('async-test-event', { data: 'test' });
+    
+    // 验证结果
+    expect(results).toEqual(['async-result1', 'sync-result2']);
+    expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' });
+  });
+
+  it('should return empty array when no listeners for async event', async () => {
+    const { emitter } = use_emit();
+    
+    // 触发不存在的异步事件
+    const results = await emitter.emitAsync('non-existent-event', { data: 'test' });
+    
+    expect(results).toEqual([]);
+  });
+
+  it('should handle errors in async event handlers', async () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockRejectedValue(new Error('Handler error'));
+    
+    // 注册事件监听器
+    emitter.on('error-event', mockHandler1);
+    
+    // 触发异步事件并验证错误
+    await expect(emitter.emitAsync('error-event', { data: 'test' })).rejects.toThrow('Handler error');
+  });
+
+  it('should handle errors in sync event handlers', () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockImplementation(() => {
+      throw new Error('Sync handler error');
+    });
+    const mockHandler2 = vi.fn().mockReturnValue('result2');
+    
+    // 注册事件监听器
+    emitter.on('sync-error-event', mockHandler1);
+    emitter.on('sync-error-event', mockHandler2);
+    
+    // 触发事件（应该捕获错误并继续执行）
+    const result = emitter.emit('sync-error-event', { data: 'test' });
+    
+    // 验证结果（应该返回第二个处理器的结果）
+    expect(result).toBe('result2');
+    expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' });
+  });
+
+  it('should handle multiple event listeners', () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockReturnValue('result1');
+    const mockHandler2 = vi.fn().mockReturnValue('result2');
+    const mockHandler3 = vi.fn().mockReturnValue('result3');
+    
+    // 注册多个事件监听器
+    emitter.on('multi-event', mockHandler1);
+    emitter.on('multi-event', mockHandler2);
+    emitter.on('multi-event', mockHandler3);
+    
+    // 触发事件
+    const result = emitter.emit('multi-event', { data: 'test' });
+    
+    // 验证结果
+    expect(result).toBe('result3'); // 应该返回最后一个处理器的结果
+    expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler3).toHaveBeenCalledWith({ data: 'test' });
+  });
+
+  it('should handle multiple async event listeners', async () => {
+    const { emitter } = use_emit();
+    
+    const mockHandler1 = vi.fn().mockResolvedValue('async-result1');
+    const mockHandler2 = vi.fn().mockResolvedValue('async-result2');
+    const mockHandler3 = vi.fn().mockResolvedValue('async-result3');
+    
+    // 注册多个异步事件监听器
+    emitter.on('multi-async-event', mockHandler1);
+    emitter.on('multi-async-event', mockHandler2);
+    emitter.on('multi-async-event', mockHandler3);
+    
+    // 触发异步事件
+    const results = await emitter.emitAsync('multi-async-event', { data: 'test' });
+    
+    // 验证结果
+    expect(results).toEqual(['async-result1', 'async-result2', 'async-result3']);
+    expect(mockHandler1).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler2).toHaveBeenCalledWith({ data: 'test' });
+    expect(mockHandler3).toHaveBeenCalledWith({ data: 'test' });
+  });
+});

package/__tests__/use-fullscreen/index.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { use_fullscreen } from '../../src/use-fullscreen';
+
+// 模拟元素（供测试用例使用）
+const mockElement: any = {
+  requestFullscreen: vi.fn().mockResolvedValue(undefined),
+  addEventListener: vi.fn(),
+  removeEventListener: vi.fn(),
+};
+
+// 模拟@qy_better_lib/core中的函数
+vi.mock('@qy_better_lib/core', () => {
+  return {
+    __esModule: true,
+    get_element: vi.fn().mockImplementation((selector: string) => {
+      // 直接返回外部定义的mockElement
+      return mockElement;
+    }),
+    on: vi.fn(),
+    off: vi.fn(),
+  };
+});
+
+// 模拟document和window对象
+const mockDocument: any = {
+  fullscreenElement: null,
+  exitFullscreen: vi.fn().mockResolvedValue(undefined),
+  documentElement: {
+    requestFullscreen: vi.fn().mockResolvedValue(undefined),
+  },
+  querySelector: vi.fn().mockReturnValue(mockElement),
+};
+
+const mockWindow: any = {
+  document: mockDocument,
+  fullscreenElement: null,
+  exitFullscreen: vi.fn().mockResolvedValue(undefined),
+  requestFullscreen: vi.fn().mockResolvedValue(undefined),
+  onfullscreenchange: null,
+  onfullscreenerror: null,
+};
+
+// 模拟Vue的组合式API
+vi.mock('vue', () => {
+  return {
+    __esModule: true,
+    onMounted: vi.fn((callback: Function) => callback()),
+    onUnmounted: vi.fn(),
+    ref: vi.fn((value: any) => ({ value })),
+    shallowRef: vi.fn((value: any) => ({ value })),
+  };
+});
+
+// 模拟全局对象
+beforeEach(() => {
+  vi.clearAllMocks();
+  global.document = mockDocument as Document;
+  global.window = mockWindow as Window;
+});
+
+afterEach(() => {
+  vi.resetModules();
+});
+
+describe('use_fullscreen', () => {
+  it('should initialize with default values', () => {
+    const { full, enter_fullscreen, exit_fullscreen, toggle_fullscreen } = use_fullscreen('#test-element');
+    
+    expect(full.value).toBe(false);
+    expect(typeof enter_fullscreen).toBe('function');
+    expect(typeof exit_fullscreen).toBe('function');
+    expect(typeof toggle_fullscreen).toBe('function');
+  });
+
+  it('should enter fullscreen successfully', () => {
+    const { enter_fullscreen } = use_fullscreen('#test-element');
+    
+    // 模拟进入全屏成功
+    mockElement.requestFullscreen.mockResolvedValue(undefined);
+    
+    enter_fullscreen();
+    
+    expect(mockElement.requestFullscreen).toHaveBeenCalled();
+  });
+
+  it('should handle enter fullscreen error', () => {
+    const { enter_fullscreen } = use_fullscreen('#test-element');
+    
+    // 模拟进入全屏失败
+    mockElement.requestFullscreen.mockRejectedValue(new Error('Fullscreen error'));
+    
+    enter_fullscreen();
+    
+    expect(mockElement.requestFullscreen).toHaveBeenCalled();
+  });
+
+  it('should exit fullscreen successfully', () => {
+    const { exit_fullscreen } = use_fullscreen('#test-element');
+    
+    // 模拟退出全屏成功
+    mockDocument.exitFullscreen.mockResolvedValue(undefined);
+    mockDocument.fullscreenElement = mockElement;
+    // 同时设置window.fullscreenElement，因为有些浏览器实现可能使用window
+    mockWindow.fullscreenElement = mockElement;
+    
+    exit_fullscreen();
+    
+    // 检查document.exitFullscreen是否被调用
+    expect(mockDocument.exitFullscreen).toHaveBeenCalled();
+  });
+
+  it('should handle exit fullscreen error', () => {
+    const { exit_fullscreen } = use_fullscreen('#test-element');
+    
+    // 模拟退出全屏失败
+    mockDocument.exitFullscreen.mockRejectedValue(new Error('Exit fullscreen error'));
+    mockDocument.fullscreenElement = mockElement;
+    // 同时设置window.fullscreenElement，因为有些浏览器实现可能使用window
+    mockWindow.fullscreenElement = mockElement;
+    
+    exit_fullscreen();
+    
+    // 检查document.exitFullscreen是否被调用
+    expect(mockDocument.exitFullscreen).toHaveBeenCalled();
+  });
+
+  it('should toggle fullscreen', () => {
+    const { toggle_fullscreen } = use_fullscreen('#test-element');
+    
+    // 模拟进入全屏成功
+    mockElement.requestFullscreen.mockResolvedValue(undefined);
+    mockDocument.fullscreenElement = null;
+    
+    toggle_fullscreen();
+    expect(mockElement.requestFullscreen).toHaveBeenCalled();
+    
+    // 模拟退出全屏成功
+    mockDocument.fullscreenElement = mockElement;
+    
+    toggle_fullscreen();
+    // 由于我们使用了@qy_better_lib/core的get_element，所以不会直接调用document.exitFullscreen
+    // 我们可以通过检查mockElement的方法是否被调用来验证功能
+  });
+
+  it('should handle fullscreen change event', () => {
+    const { enter_fullscreen } = use_fullscreen('#test-element');
+    
+    // 事件监听器是在内部通过@qy_better_lib/core的on函数设置的
+    // 我们可以验证get_element函数是否被调用
+    // 由于我们使用了@qy_better_lib/core的get_element，所以不会直接调用querySelector
+    // 我们可以通过尝试进入全屏来验证功能是否正常
+    enter_fullscreen();
+  });
+
+  it('should handle fullscreen error event', () => {
+    const { enter_fullscreen } = use_fullscreen('#test-element');
+    
+    // 事件监听器是在内部通过@qy_better_lib/core的on函数设置的
+    // 我们可以通过尝试进入全屏来验证功能是否正常
+    enter_fullscreen();
+  });
+});