import { ICommandInfo, WebTerm, parseCommand } from 'web-term-ui';

/*
 * @Author: chenzhongsheng
 * @Date: 2024-11-30 11:30:49
 * @Description: Coding something
 */
export type IPromiseData<T extends Promise<any>> = T extends Promise<infer U> ? U : any;
export type IPromiseMaybe<T = any> = Promise<T> | T;
export type IFnMaybe<T = any> = T | (() => T);
export type IOprateResult<T extends Record<string, any> = {}> = {
	success: boolean;
	info: string;
} & T;
export interface ICommand<T = any> {
	name: string;
	helpDetails?: IFnMaybe<string>;
	version?: IFnMaybe<string>;
	helpInfo?: IFnMaybe<string>;
	run(cmd: ICommandInfo, context: {
		commands: ICommandInfo[];
		disk: T;
		data: string;
		term: WebTerm;
		run: (line: string | ICommandInfo[]) => Promise<string | boolean>;
	}): IPromiseMaybe<string | boolean>;
	activate?(disk: T, provider: ICommandProvider): void;
	dispose?(): void;
}
export interface ICommandProvider<T = any> {
	getPwd: () => string;
	onTab?: (value: string, full: string) => IPromiseMaybe<({
		line?: string;
		result: string;
	})>;
	onCommand: (commands: ICommandInfo[], methods: {
		setPwd: (v: string) => void;
		clearTerminal: () => void;
		getHeader: () => string;
		openEditor: (options: {
			path: string;
			content: string;
			save: (v: string) => void;
		}) => void;
	}) => IPromiseMaybe<string | boolean>;
	registerCommand?(command: ICommand<T>): IOprateResult;
	removeCommand?(name: string): IOprateResult;
}
export interface IPos {
	x: number;
	y: number;
}
export declare const TerminalControlKey: {
	readonly "\r": "Enter";
	readonly "": "Backspace";
	readonly "\u001B[A": "Up";
	readonly "\u001B[B": "Down";
	readonly "\u001B[D": "Left";
	readonly "\u001B[C": "Right";
	readonly "\t": "Tab";
};
export declare const TerminalKeys: ("Enter" | "Tab" | "Backspace" | "Up" | "Down" | "Left" | "Right")[];
export declare const TerminalKeysSet: Set<"Enter" | "Tab" | "Backspace" | "Up" | "Down" | "Left" | "Right">;
export type ITerminalKey = typeof TerminalKeys[number];
export interface ITerminalEditor {
	addRecord(v: string): void;
	clearRecord(): void;
	edit(v: string): void;
	back(): void;
	onKey(key: ITerminalKey, v?: string): boolean;
	initTerminalManager(manager: ITerminalManager): void;
	isEditing: boolean;
}
export interface ITerminalInfo {
	x: number;
	y: number;
	length: number;
	rows: number;
	cols: number;
}
export interface ITerminalProvider {
	editor?: ITerminalEditor;
	title?: string;
	write(data: string): void;
	getHeader(): string;
	onTab?(value: string, full: string): IPromiseMaybe<string>;
	onCommand?(commands: ICommandInfo[]): IPromiseMaybe<string | boolean>;
	onEnter?(line: string): IPromiseMaybe<string | boolean>;
	onData(ln: (data: string) => void): void;
	getTermInfo(): ITerminalInfo;
}
export interface ITerminalManager {
	name: string;
	line: string;
	cursorIndex: number;
	provider: ITerminalProvider;
	get header(): string;
	clear(pure?: boolean): void;
	setCursorPos(x: number, y: number): void;
	write(data: string): void;
	writeLine(text: string, lines?: number): void;
	writeEmptyLine(): void;
	cursorMove(count?: number): number;
	cursorMoveToTail(): void;
	cursorMoveToHead(): void;
	replaceCurrentLine(value: string): void;
	delete(count?: number): void;
	deleteAll(): void;
	onHandleTerminalData(data: string): Promise<void>;
	insertLine(content: string): void;
}
export declare function notImplemented(): void;
export declare function notImplementedAsync<T = any>(): Promise<T>;
export declare function attachTarget(obj: any, target: any): void;
export declare function withResolve<T = any, Err = any>(): {
	ready: Promise<T>;
	resolve: (data?: T) => void;
	reject: (Err?: Err) => void;
};
export declare function mergeU8s(...u8s: Uint8Array[]): Uint8Array<ArrayBuffer>;
export declare function isU8sEqual(u8s1: Uint8Array, u8s2: Uint8Array | null): boolean;
export declare function copyU8s(u8s: Uint8Array): Uint8Array<ArrayBuffer>;
export declare function io<T extends Promise<any>>(promise: T): Promise<[
	IPromiseData<T>,
	any
]>;
export declare function encode(v: string): Uint8Array<ArrayBufferLike>;
export declare function decode(v: Uint8Array): string;
export declare function runPromises(ps: (() => Promise<any>)[]): Promise<void>;
export declare function createPromises<T = any>(): {
	add: (v: Promise<T>) => void;
	run: () => Promise<Awaited<T>[]>;
};
export type DebounceFunction<T extends (...args: any[]) => any> = (this: ThisParameterType<T>, ...args: Parameters<T>) => void;
export declare function debounce<T extends (...args: any[]) => any>(func: T, delay: number): DebounceFunction<T>;
export declare function splitPathInfo(path: string): {
	path: string;
	parent: string;
	name: string;
};
export declare function asyncAll<T = any>(): {
	add(pro: Promise<T>): void;
	run(): Promise<Awaited<T>[]>;
};
export declare function runPromiseMaybe<T = any>(v: IPromiseMaybe<T>): Promise<T>;
export declare function runFnMaybe<T>(v: T | (() => T)): T;
export declare function mergePositions(...ps: IPos[]): IPos;
export declare function mergeText(target: string, addon: string, index?: number): string;
export declare function removeText(text: string, index: number): string;
export declare function geneText(size: number, fill: string): string;
export declare function isMac(): boolean;
export declare function isHttpLink(v: string): boolean;
export declare function fetchJson<T extends Record<string, any> = Record<string, any>>(url: string): Promise<T | null>;
export declare function fetchText(url: string): Promise<string>;
export declare function executeJS(code: string): Promise<boolean>;
export declare function executeJSWithFn<T = void>(code: string, args?: Record<string, any>): T;
export interface ICommandOptions<T = any> {
	commands: ICommandInfo[];
	disk: T;
	data: string;
	term: WebTerm;
	run: (line: string | ICommandInfo[]) => Promise<boolean | string>;
}
export declare class BaseCommand<T> implements ICommand<T> {
	name: string;
	helpInfo: IFnMaybe<string>;
	helpDetails: IFnMaybe<string>;
	term: WebTerm;
	disk: T;
	provider: ICommandProvider;
	activate(disk: T, provider: ICommandProvider): void;
	run(cmd: ICommandInfo, options: ICommandOptions<T>): IPromiseMaybe<string | boolean>;
}
export declare function parseGithubFile(v: string, dfFile?: string): string;
export declare function parseNPMFile(v: string, useUnpkg?: boolean): string;

export {
	ICommandInfo,
	WebTerm,
	parseCommand,
};

export {};