feat: shell history (#1169)
This commit is contained in:
parent
443465a805
commit
f3c1cbbabf
|
@ -0,0 +1,187 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { render } from 'ink-testing-library';
|
||||
import { InputPrompt, InputPromptProps } from './InputPrompt.js';
|
||||
import type { TextBuffer } from './shared/text-buffer.js';
|
||||
import { Config } from '@gemini-cli/core';
|
||||
import { vi } from 'vitest';
|
||||
import { useShellHistory } from '../hooks/useShellHistory.js';
|
||||
import { useCompletion } from '../hooks/useCompletion.js';
|
||||
import { useInputHistory } from '../hooks/useInputHistory.js';
|
||||
|
||||
vi.mock('../hooks/useShellHistory.js');
|
||||
vi.mock('../hooks/useCompletion.js');
|
||||
vi.mock('../hooks/useInputHistory.js');
|
||||
|
||||
type MockedUseShellHistory = ReturnType<typeof useShellHistory>;
|
||||
type MockedUseCompletion = ReturnType<typeof useCompletion>;
|
||||
type MockedUseInputHistory = ReturnType<typeof useInputHistory>;
|
||||
|
||||
describe('InputPrompt', () => {
|
||||
let props: InputPromptProps;
|
||||
let mockShellHistory: MockedUseShellHistory;
|
||||
let mockCompletion: MockedUseCompletion;
|
||||
let mockInputHistory: MockedUseInputHistory;
|
||||
let mockBuffer: TextBuffer;
|
||||
|
||||
const mockedUseShellHistory = vi.mocked(useShellHistory);
|
||||
const mockedUseCompletion = vi.mocked(useCompletion);
|
||||
const mockedUseInputHistory = vi.mocked(useInputHistory);
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks();
|
||||
|
||||
mockBuffer = {
|
||||
text: '',
|
||||
cursor: [0, 0],
|
||||
lines: [''],
|
||||
setText: vi.fn((newText: string) => {
|
||||
mockBuffer.text = newText;
|
||||
mockBuffer.lines = [newText];
|
||||
mockBuffer.cursor = [0, newText.length];
|
||||
mockBuffer.viewportVisualLines = [newText];
|
||||
mockBuffer.allVisualLines = [newText];
|
||||
}),
|
||||
viewportVisualLines: [''],
|
||||
allVisualLines: [''],
|
||||
visualCursor: [0, 0],
|
||||
visualScrollRow: 0,
|
||||
handleInput: vi.fn(),
|
||||
move: vi.fn(),
|
||||
moveToOffset: vi.fn(),
|
||||
killLineRight: vi.fn(),
|
||||
killLineLeft: vi.fn(),
|
||||
openInExternalEditor: vi.fn(),
|
||||
newline: vi.fn(),
|
||||
replaceRangeByOffset: vi.fn(),
|
||||
} as unknown as TextBuffer;
|
||||
|
||||
mockShellHistory = {
|
||||
addCommandToHistory: vi.fn(),
|
||||
getPreviousCommand: vi.fn().mockReturnValue(null),
|
||||
getNextCommand: vi.fn().mockReturnValue(null),
|
||||
resetHistoryPosition: vi.fn(),
|
||||
};
|
||||
mockedUseShellHistory.mockReturnValue(mockShellHistory);
|
||||
|
||||
mockCompletion = {
|
||||
suggestions: [],
|
||||
activeSuggestionIndex: -1,
|
||||
isLoadingSuggestions: false,
|
||||
showSuggestions: false,
|
||||
visibleStartIndex: 0,
|
||||
navigateUp: vi.fn(),
|
||||
navigateDown: vi.fn(),
|
||||
resetCompletionState: vi.fn(),
|
||||
setActiveSuggestionIndex: vi.fn(),
|
||||
setShowSuggestions: vi.fn(),
|
||||
};
|
||||
mockedUseCompletion.mockReturnValue(mockCompletion);
|
||||
|
||||
mockInputHistory = {
|
||||
navigateUp: vi.fn(),
|
||||
navigateDown: vi.fn(),
|
||||
handleSubmit: vi.fn(),
|
||||
};
|
||||
mockedUseInputHistory.mockReturnValue(mockInputHistory);
|
||||
|
||||
props = {
|
||||
buffer: mockBuffer,
|
||||
onSubmit: vi.fn(),
|
||||
userMessages: [],
|
||||
onClearScreen: vi.fn(),
|
||||
config: {
|
||||
getProjectRoot: () => '/test/project',
|
||||
getTargetDir: () => '/test/project/src',
|
||||
} as unknown as Config,
|
||||
slashCommands: [],
|
||||
shellModeActive: false,
|
||||
setShellModeActive: vi.fn(),
|
||||
inputWidth: 80,
|
||||
suggestionsWidth: 80,
|
||||
focus: true,
|
||||
};
|
||||
});
|
||||
|
||||
const wait = (ms = 50) => new Promise((resolve) => setTimeout(resolve, ms));
|
||||
|
||||
it('should call shellHistory.getPreviousCommand on up arrow in shell mode', async () => {
|
||||
props.shellModeActive = true;
|
||||
const { stdin, unmount } = render(<InputPrompt {...props} />);
|
||||
await wait();
|
||||
|
||||
stdin.write('\u001B[A');
|
||||
await wait();
|
||||
|
||||
expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
|
||||
unmount();
|
||||
});
|
||||
|
||||
it('should call shellHistory.getNextCommand on down arrow in shell mode', async () => {
|
||||
props.shellModeActive = true;
|
||||
const { stdin, unmount } = render(<InputPrompt {...props} />);
|
||||
await wait();
|
||||
|
||||
stdin.write('\u001B[B');
|
||||
await wait();
|
||||
|
||||
expect(mockShellHistory.getNextCommand).toHaveBeenCalled();
|
||||
unmount();
|
||||
});
|
||||
|
||||
it('should set the buffer text when a shell history command is retrieved', async () => {
|
||||
props.shellModeActive = true;
|
||||
vi.mocked(mockShellHistory.getPreviousCommand).mockReturnValue(
|
||||
'previous command',
|
||||
);
|
||||
const { stdin, unmount } = render(<InputPrompt {...props} />);
|
||||
await wait();
|
||||
|
||||
stdin.write('\u001B[A');
|
||||
await wait();
|
||||
|
||||
expect(mockShellHistory.getPreviousCommand).toHaveBeenCalled();
|
||||
expect(props.buffer.setText).toHaveBeenCalledWith('previous command');
|
||||
unmount();
|
||||
});
|
||||
|
||||
it('should call shellHistory.addCommandToHistory on submit in shell mode', async () => {
|
||||
props.shellModeActive = true;
|
||||
props.buffer.setText('ls -l');
|
||||
const { stdin, unmount } = render(<InputPrompt {...props} />);
|
||||
await wait();
|
||||
|
||||
stdin.write('\r');
|
||||
await wait();
|
||||
|
||||
expect(mockShellHistory.addCommandToHistory).toHaveBeenCalledWith('ls -l');
|
||||
expect(props.onSubmit).toHaveBeenCalledWith('ls -l');
|
||||
unmount();
|
||||
});
|
||||
|
||||
it('should NOT call shell history methods when not in shell mode', async () => {
|
||||
props.buffer.setText('some text');
|
||||
const { stdin, unmount } = render(<InputPrompt {...props} />);
|
||||
await wait();
|
||||
|
||||
stdin.write('\u001B[A'); // Up arrow
|
||||
await wait();
|
||||
stdin.write('\u001B[B'); // Down arrow
|
||||
await wait();
|
||||
stdin.write('\r'); // Enter
|
||||
await wait();
|
||||
|
||||
expect(mockShellHistory.getPreviousCommand).not.toHaveBeenCalled();
|
||||
expect(mockShellHistory.getNextCommand).not.toHaveBeenCalled();
|
||||
expect(mockShellHistory.addCommandToHistory).not.toHaveBeenCalled();
|
||||
|
||||
expect(mockInputHistory.navigateUp).toHaveBeenCalled();
|
||||
expect(mockInputHistory.navigateDown).toHaveBeenCalled();
|
||||
expect(props.onSubmit).toHaveBeenCalledWith('some text');
|
||||
unmount();
|
||||
});
|
||||
});
|
|
@ -13,6 +13,7 @@ import { cpSlice, cpLen, TextBuffer } from './shared/text-buffer.js';
|
|||
import chalk from 'chalk';
|
||||
import stringWidth from 'string-width';
|
||||
import process from 'node:process';
|
||||
import { useShellHistory } from '../hooks/useShellHistory.js';
|
||||
import { useCompletion } from '../hooks/useCompletion.js';
|
||||
import { isAtCommand, isSlashCommand } from '../utils/commandUtils.js';
|
||||
import { SlashCommand } from '../hooks/slashCommandProcessor.js';
|
||||
|
@ -58,16 +59,20 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
|
|||
);
|
||||
|
||||
const resetCompletionState = completion.resetCompletionState;
|
||||
const shellHistory = useShellHistory(config.getProjectRoot());
|
||||
|
||||
const handleSubmitAndClear = useCallback(
|
||||
(submittedValue: string) => {
|
||||
if (shellModeActive) {
|
||||
shellHistory.addCommandToHistory(submittedValue);
|
||||
}
|
||||
// Clear the buffer *before* calling onSubmit to prevent potential re-submission
|
||||
// if onSubmit triggers a re-render while the buffer still holds the old value.
|
||||
buffer.setText('');
|
||||
onSubmit(submittedValue);
|
||||
resetCompletionState();
|
||||
},
|
||||
[onSubmit, buffer, resetCompletionState],
|
||||
[onSubmit, buffer, resetCompletionState, shellModeActive, shellHistory],
|
||||
);
|
||||
|
||||
const customSetTextAndResetCompletionSignal = useCallback(
|
||||
|
@ -81,7 +86,7 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
|
|||
const inputHistory = useInputHistory({
|
||||
userMessages,
|
||||
onSubmit: handleSubmitAndClear,
|
||||
isActive: !completion.showSuggestions,
|
||||
isActive: !completion.showSuggestions && !shellModeActive,
|
||||
currentQuery: buffer.text,
|
||||
onChange: customSetTextAndResetCompletionSignal,
|
||||
});
|
||||
|
@ -304,6 +309,13 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
|
|||
|
||||
// Standard arrow navigation within the buffer
|
||||
if (key.upArrow && !completion.showSuggestions) {
|
||||
if (shellModeActive) {
|
||||
const prevCommand = shellHistory.getPreviousCommand();
|
||||
if (prevCommand !== null) {
|
||||
buffer.setText(prevCommand);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (
|
||||
(buffer.allVisualLines.length === 1 || // Always navigate for single line
|
||||
(buffer.visualCursor[0] === 0 && buffer.visualScrollRow === 0)) &&
|
||||
|
@ -316,6 +328,13 @@ export const InputPrompt: React.FC<InputPromptProps> = ({
|
|||
return;
|
||||
}
|
||||
if (key.downArrow && !completion.showSuggestions) {
|
||||
if (shellModeActive) {
|
||||
const nextCommand = shellHistory.getNextCommand();
|
||||
if (nextCommand !== null) {
|
||||
buffer.setText(nextCommand);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (
|
||||
(buffer.allVisualLines.length === 1 || // Always navigate for single line
|
||||
buffer.visualCursor[0] === buffer.allVisualLines.length - 1) &&
|
||||
|
|
|
@ -0,0 +1,198 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { renderHook, act, waitFor } from '@testing-library/react';
|
||||
import { useShellHistory } from './useShellHistory.js';
|
||||
import * as fs from 'fs/promises';
|
||||
import path from 'path';
|
||||
|
||||
vi.mock('fs/promises');
|
||||
|
||||
const MOCKED_PROJECT_ROOT = '/test/project';
|
||||
const MOCKED_HISTORY_DIR = path.join(MOCKED_PROJECT_ROOT, '.gemini');
|
||||
const MOCKED_HISTORY_FILE = path.join(MOCKED_HISTORY_DIR, 'shell_history');
|
||||
|
||||
describe('useShellHistory', () => {
|
||||
const mockedFs = vi.mocked(fs);
|
||||
|
||||
beforeEach(() => {
|
||||
vi.resetAllMocks();
|
||||
|
||||
mockedFs.readFile.mockResolvedValue('');
|
||||
mockedFs.writeFile.mockResolvedValue(undefined);
|
||||
mockedFs.mkdir.mockResolvedValue(undefined);
|
||||
});
|
||||
|
||||
it('should initialize and read the history file from the correct path', async () => {
|
||||
mockedFs.readFile.mockResolvedValue('cmd1\ncmd2');
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
|
||||
await waitFor(() => {
|
||||
expect(mockedFs.readFile).toHaveBeenCalledWith(
|
||||
MOCKED_HISTORY_FILE,
|
||||
'utf-8',
|
||||
);
|
||||
});
|
||||
|
||||
let command: string | null = null;
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
|
||||
// History is loaded newest-first: ['cmd2', 'cmd1']
|
||||
expect(command).toBe('cmd2');
|
||||
});
|
||||
|
||||
it('should handle a non-existent history file gracefully', async () => {
|
||||
const error = new Error('File not found') as NodeJS.ErrnoException;
|
||||
error.code = 'ENOENT';
|
||||
mockedFs.readFile.mockRejectedValue(error);
|
||||
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
|
||||
await waitFor(() => {
|
||||
expect(mockedFs.readFile).toHaveBeenCalled();
|
||||
});
|
||||
|
||||
let command: string | null = null;
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
|
||||
expect(command).toBe(null);
|
||||
});
|
||||
|
||||
it('should add a command and write to the history file', async () => {
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
|
||||
await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
|
||||
|
||||
act(() => {
|
||||
result.current.addCommandToHistory('new_command');
|
||||
});
|
||||
|
||||
await waitFor(() => {
|
||||
expect(mockedFs.mkdir).toHaveBeenCalledWith(MOCKED_HISTORY_DIR, {
|
||||
recursive: true,
|
||||
});
|
||||
expect(mockedFs.writeFile).toHaveBeenCalledWith(
|
||||
MOCKED_HISTORY_FILE,
|
||||
'new_command', // Written to file oldest-first.
|
||||
);
|
||||
});
|
||||
|
||||
let command: string | null = null;
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
expect(command).toBe('new_command');
|
||||
});
|
||||
|
||||
it('should navigate history correctly with previous/next commands', async () => {
|
||||
mockedFs.readFile.mockResolvedValue('cmd1\ncmd2\ncmd3');
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
|
||||
// Wait for history to be loaded: ['cmd3', 'cmd2', 'cmd1']
|
||||
await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
|
||||
|
||||
let command: string | null = null;
|
||||
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
expect(command).toBe('cmd3');
|
||||
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
expect(command).toBe('cmd2');
|
||||
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
expect(command).toBe('cmd1');
|
||||
|
||||
// Should stay at the oldest command
|
||||
act(() => {
|
||||
command = result.current.getPreviousCommand();
|
||||
});
|
||||
expect(command).toBe('cmd1');
|
||||
|
||||
act(() => {
|
||||
command = result.current.getNextCommand();
|
||||
});
|
||||
expect(command).toBe('cmd2');
|
||||
|
||||
act(() => {
|
||||
command = result.current.getNextCommand();
|
||||
});
|
||||
expect(command).toBe('cmd3');
|
||||
|
||||
// Should return to the "new command" line (represented as empty string)
|
||||
act(() => {
|
||||
command = result.current.getNextCommand();
|
||||
});
|
||||
expect(command).toBe('');
|
||||
});
|
||||
|
||||
it('should not add empty or whitespace-only commands to history', async () => {
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
|
||||
|
||||
act(() => {
|
||||
result.current.addCommandToHistory(' ');
|
||||
});
|
||||
|
||||
expect(mockedFs.writeFile).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('should truncate history to MAX_HISTORY_LENGTH (100)', async () => {
|
||||
const oldCommands = Array.from({ length: 120 }, (_, i) => `old_cmd_${i}`);
|
||||
mockedFs.readFile.mockResolvedValue(oldCommands.join('\n'));
|
||||
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
|
||||
|
||||
act(() => {
|
||||
result.current.addCommandToHistory('new_cmd');
|
||||
});
|
||||
|
||||
// Wait for the async write to happen and then inspect the arguments.
|
||||
await waitFor(() => expect(mockedFs.writeFile).toHaveBeenCalled());
|
||||
|
||||
// The hook stores history newest-first.
|
||||
// Initial state: ['old_cmd_119', ..., 'old_cmd_0']
|
||||
// After adding 'new_cmd': ['new_cmd', 'old_cmd_119', ..., 'old_cmd_21'] (100 items)
|
||||
// Written to file (reversed): ['old_cmd_21', ..., 'old_cmd_119', 'new_cmd']
|
||||
const writtenContent = mockedFs.writeFile.mock.calls[0][1] as string;
|
||||
const writtenLines = writtenContent.split('\n');
|
||||
|
||||
expect(writtenLines.length).toBe(100);
|
||||
expect(writtenLines[0]).toBe('old_cmd_21'); // New oldest command
|
||||
expect(writtenLines[99]).toBe('new_cmd'); // Newest command
|
||||
});
|
||||
|
||||
it('should move an existing command to the top when re-added', async () => {
|
||||
mockedFs.readFile.mockResolvedValue('cmd1\ncmd2\ncmd3');
|
||||
const { result } = renderHook(() => useShellHistory(MOCKED_PROJECT_ROOT));
|
||||
|
||||
// Initial state: ['cmd3', 'cmd2', 'cmd1']
|
||||
await waitFor(() => expect(mockedFs.readFile).toHaveBeenCalled());
|
||||
|
||||
act(() => {
|
||||
result.current.addCommandToHistory('cmd1');
|
||||
});
|
||||
|
||||
// After re-adding 'cmd1': ['cmd1', 'cmd3', 'cmd2']
|
||||
// Written to file (reversed): ['cmd2', 'cmd3', 'cmd1']
|
||||
await waitFor(() => expect(mockedFs.writeFile).toHaveBeenCalled());
|
||||
|
||||
const writtenContent = mockedFs.writeFile.mock.calls[0][1] as string;
|
||||
const writtenLines = writtenContent.split('\n');
|
||||
|
||||
expect(writtenLines).toEqual(['cmd2', 'cmd3', 'cmd1']);
|
||||
});
|
||||
});
|
|
@ -0,0 +1,104 @@
|
|||
/**
|
||||
* @license
|
||||
* Copyright 2025 Google LLC
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*/
|
||||
|
||||
import { useState, useEffect, useCallback } from 'react';
|
||||
import * as fs from 'fs/promises';
|
||||
import * as path from 'path';
|
||||
import { isNodeError } from '@gemini-cli/core';
|
||||
|
||||
const HISTORY_DIR = '.gemini';
|
||||
const HISTORY_FILE = 'shell_history';
|
||||
const MAX_HISTORY_LENGTH = 100;
|
||||
|
||||
async function getHistoryFilePath(projectRoot: string): Promise<string> {
|
||||
const historyDir = path.join(projectRoot, HISTORY_DIR);
|
||||
return path.join(historyDir, HISTORY_FILE);
|
||||
}
|
||||
|
||||
async function readHistoryFile(filePath: string): Promise<string[]> {
|
||||
try {
|
||||
const content = await fs.readFile(filePath, 'utf-8');
|
||||
return content.split('\n').filter(Boolean);
|
||||
} catch (error) {
|
||||
if (isNodeError(error) && error.code === 'ENOENT') {
|
||||
return [];
|
||||
}
|
||||
console.error('Error reading shell history:', error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
async function writeHistoryFile(
|
||||
filePath: string,
|
||||
history: string[],
|
||||
): Promise<void> {
|
||||
try {
|
||||
await fs.mkdir(path.dirname(filePath), { recursive: true });
|
||||
await fs.writeFile(filePath, history.join('\n'));
|
||||
} catch (error) {
|
||||
console.error('Error writing shell history:', error);
|
||||
}
|
||||
}
|
||||
|
||||
export function useShellHistory(projectRoot: string) {
|
||||
const [history, setHistory] = useState<string[]>([]);
|
||||
const [historyIndex, setHistoryIndex] = useState(-1);
|
||||
const [historyFilePath, setHistoryFilePath] = useState<string | null>(null);
|
||||
|
||||
useEffect(() => {
|
||||
async function loadHistory() {
|
||||
const filePath = await getHistoryFilePath(projectRoot);
|
||||
setHistoryFilePath(filePath);
|
||||
const loadedHistory = await readHistoryFile(filePath);
|
||||
setHistory(loadedHistory.reverse()); // Newest first
|
||||
}
|
||||
loadHistory();
|
||||
}, [projectRoot]);
|
||||
|
||||
const addCommandToHistory = useCallback(
|
||||
(command: string) => {
|
||||
if (!command.trim() || !historyFilePath) {
|
||||
return;
|
||||
}
|
||||
const newHistory = [command, ...history.filter((c) => c !== command)]
|
||||
.slice(0, MAX_HISTORY_LENGTH)
|
||||
.filter(Boolean);
|
||||
setHistory(newHistory);
|
||||
// Write to file in reverse order (oldest first)
|
||||
writeHistoryFile(historyFilePath, [...newHistory].reverse());
|
||||
setHistoryIndex(-1);
|
||||
},
|
||||
[history, historyFilePath],
|
||||
);
|
||||
|
||||
const getPreviousCommand = useCallback(() => {
|
||||
if (history.length === 0) {
|
||||
return null;
|
||||
}
|
||||
const newIndex = Math.min(historyIndex + 1, history.length - 1);
|
||||
setHistoryIndex(newIndex);
|
||||
return history[newIndex] ?? null;
|
||||
}, [history, historyIndex]);
|
||||
|
||||
const getNextCommand = useCallback(() => {
|
||||
if (historyIndex < 0) {
|
||||
return null;
|
||||
}
|
||||
const newIndex = historyIndex - 1;
|
||||
setHistoryIndex(newIndex);
|
||||
if (newIndex < 0) {
|
||||
return '';
|
||||
}
|
||||
return history[newIndex] ?? null;
|
||||
}, [history, historyIndex]);
|
||||
|
||||
return {
|
||||
addCommandToHistory,
|
||||
getPreviousCommand,
|
||||
getNextCommand,
|
||||
resetHistoryPosition: () => setHistoryIndex(-1),
|
||||
};
|
||||
}
|
Loading…
Reference in New Issue