import { Buffer } from 'buffer';
import { EventEmitter } from 'events';
import _localforage from 'localforage';
import * as Path from 'node:path';
import { ICommandInfo, WebTerm, parseCommand } from 'web-term-ui';

export declare function getMaxCommonHead(values: string[], start?: number): string;
export type NodePath = typeof Path;
export type IFileType = "empty" | "file" | "dir" | "link";
export interface IFileStats {
	size: number;
	type: IFileType;
	isDirectory(): boolean;
	isFile(): boolean;
}
/*
 * @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;
declare class StorageBackEnd {
	static Supported(): boolean;
	private root;
	init(): Promise<void>;
	read(path: string): Promise<Uint8Array | null>;
	write(path: string, data: Uint8Array): Promise<boolean>;
	private _writeFile;
	append(path: string, data: Uint8Array): Promise<boolean>;
	remove(path: string): Promise<boolean>;
	stat(path: string, recursive?: boolean): Promise<Pick<IFileStats, "size" | "type">>;
	private _isLinkFile;
	private traverse;
	traverseContent(callback: (path: string, content: Promise<Uint8Array | null>, name: string) => IPromiseMaybe<void>, path?: string, read?: boolean): Promise<void>;
	private _traverseContent;
	exist(path: string): Promise<boolean>;
	ls(path: string): Promise<string[] | null>;
	private existInDir;
	createLink(path: string, target: string, overwrite?: boolean): Promise<boolean>;
	createFile(path: string, content?: Uint8Array, overwrite?: boolean): Promise<boolean>;
	createDir(path: string, overwrite?: boolean): Promise<boolean>;
	private clearTarget;
	private _readFile;
	private getHandleByPath;
	private getParentByPath;
	getType(path: string): Promise<IFileType>;
}
export type IDiskBankEnd = Pick<InstanceType<typeof StorageBackEnd>, "init" | "read" | "write" | "append" | "remove" | "stat" | "exist" | "ls" | "createDir" | "createFile" | "traverseContent" | "getType">;
declare class SyncMiddleware {
	/**
	 * 内存中存在的存储所有文件的map，用于同步方法的实现
	 * 初始化时需要遍历存储的所有文件，将其加载到内存中
	 * 读写时需要同步
	 */
	private fileMap;
	init(backend: IDiskBankEnd): Promise<void>;
	read(key: string): Uint8Array<ArrayBufferLike> | null;
	pureRead(key: string): Uint8Array<ArrayBufferLike>;
	write(key: string, content: Uint8Array): boolean;
	append(key: string, content: Uint8Array): boolean;
	remove(path: string, onRemove?: (path: string) => void): boolean;
	private _removeSingle;
	stat(path: string, recursive?: boolean): {
		size: number;
		type: IFileType;
	};
	exist(path: string): boolean;
	ls(path: string): string[];
	createFile(path: string, content?: Uint8Array<ArrayBuffer>, overwrite?: boolean): boolean;
	createDir(path: string, overwrite?: boolean): boolean;
	getType(path: string): IFileType;
	traverse(path: string, callback: (data: {
		path: string;
		parent: string;
		name: string;
	}) => void, includeSelf?: boolean): void;
	traverseContent(callback: (path: string, content: Uint8Array | null) => void, path?: string): void;
}
declare class Link {
	backend: IDiskBankEnd;
	syncMiddleware?: SyncMiddleware | undefined;
	constructor(backend: IDiskBankEnd, syncMiddleware?: SyncMiddleware | undefined);
	get(path: string, data?: Uint8Array): Promise<string>;
	getSync(path: string, data?: Uint8Array): string;
	private _get;
}
declare class Zip {
	disk: Disk;
	constructor(disk: Disk);
	zip(paths: string[], target?: string): Promise<IOprateResult>;
	private zipSingleFile;
	unzip(path: string, target?: string): Promise<{
		path: string;
		isDir: boolean;
	}[]>;
	private unzipU8Arr;
	isZip(path: string): Promise<boolean>;
	private isZipData;
	private getZipData;
}
export type IWatchEncoding = BufferEncoding | "buffer";
export interface IWatchOptions {
	persistent?: boolean;
	recursive?: boolean;
	encoding?: IWatchEncoding;
}
export type IWatchCallback = (event: "rename" | "change", path: string | Buffer) => void;
declare class FSWatcher extends EventEmitter<{
	change: [
		"rename" | "change",
		string | Buffer
	];
	error: [
		Error
	];
}> {
	watch: Watch;
	options: Required<IWatchOptions>;
	callback: IWatchCallback;
	path: string;
	constructor({ watch, options, callback, path, }: {
		watch: Watch;
		options: IWatchOptions;
		callback: IWatchCallback;
		path: string;
		enabled?: boolean;
	});
	static empty(): FSWatcher;
	close(): void;
	checkChange(path: string, type: "rename" | "change"): void;
}
export type IFileListener = (curr: IFileStats, prev: IFileStats) => void;
export interface IFileWatchOptions {
	bigint?: boolean;
	persistent?: boolean;
	interval?: number;
}
declare class Watch {
	disk: Disk;
	events: EventEmitter<[
		never
	]>;
	watchers: FSWatcher[];
	fileWatchers: Record<string, IFileListener[]>;
	constructor(disk: Disk);
	fireRename(path: string, isRemove?: boolean, emit?: boolean): void;
	fireChange(path: string, emit?: boolean): Promise<(() => void) | null>;
	fireChangeSync(path: string, emit?: boolean): (() => void) | null;
	watch(path: string, options: IWatchOptions | IWatchEncoding | IWatchCallback, callback?: IWatchCallback): FSWatcher;
	watchFile(path: string, options: IFileWatchOptions | IFileListener, callback?: IFileListener): void;
	unwatchFile(path: string, callback?: IFileListener): void;
}
declare class SyncProxy {
	syncMiddleware: SyncMiddleware;
	disk: Disk;
	constructor(disk: Disk);
	init(): Promise<void>;
	fmtPath(path: string): string;
	get _link(): Link;
	get _watch(): Watch;
	get backend(): IDiskBankEnd;
	size(path?: string): number;
	cd(path: string): boolean;
	isDir(path: string): boolean;
	getType(path: string): IFileType;
	pwd(): string;
	copy(files: string | string[]): boolean;
	cut(files: string | string[]): boolean;
	move(source: string, target: string, onFinalName?: (v: string) => void): string;
	rename(path: string, name: string, onFinalName?: (v: string) => void): string;
	paste(targetDir: string, renameMap?: Record<string, string>, onFinalName?: (map: Record<string, string>) => void): string;
	pasteBase(targetDir: string, clipboard: IClipboard, renameMap?: Record<string, string>, onFinalName?: (map: Record<string, string>) => void): string;
	ls(path?: string): string[] | null;
	remove(path: string): boolean;
	clear(): void;
	copySingle(source: string, target: string): boolean;
	traverseContent(path: string, callback: (path: string, content: Uint8Array | null, name: string) => void): void;
	traverse(path: string, callback: (data: {
		path: string;
		parent: string;
		name: string;
	}) => void): void;
	read(path: string): Uint8Array | null;
	readText(path: string): string | null;
	write(path: string, data: Uint8Array): boolean;
	append(path: string, data: Uint8Array): boolean;
	exist(path: string): boolean;
	stat(path: string, recursive?: boolean): IFileStats;
	createFile(path: string, content?: Uint8Array | undefined, opt?: ICreateOpt): boolean;
	createDir(path: string, opt?: ICreateOpt): boolean;
	createLink(path: string, target: string, opt?: ICreateOpt): boolean;
	_create(path: string, content?: Uint8Array | undefined, { overwrite, ensure }?: ICreateOpt, isDir?: boolean, onCreateAsync?: (v: () => Promise<boolean>) => void): boolean;
	ensureParentPath(path: string): Promise<void>;
	_ensureParentPath(path: string): void;
}
declare enum ChangType {
	Create = 0,
	Remove = 1,
	Change = 2
}
declare class UpdateManager {
	tempChange: Record<string, ChangType>;
	timer: any;
	lastOprateId: string;
	disk: Disk;
	private offWatch;
	constructor(disk: Disk);
	init(): void;
	get sync(): SyncMiddleware;
	checkUpdate(): Promise<void>;
	private writeFile;
	private useChanges;
	checkWriteChange(): Promise<void>;
	clear(): void;
}
export interface ICreateOpt {
	ensure?: boolean;
	overwrite?: boolean;
}
export type IDisk = Omit<IDiskBankEnd, "init" | "traverseContent"> & {
	createDir: (path: string, opt?: ICreateOpt) => Promise<boolean>;
	createLink: (path: string, target: string, opt?: ICreateOpt) => Promise<boolean>;
	createFile: (path: string, content: Uint8Array, overwrite?: boolean) => Promise<boolean>;
};
export interface IDiskOption {
	enableSync?: boolean;
}
export interface IClipboard {
	paths: string[];
	isCut: boolean;
	active: boolean;
}
export declare class Disk implements IDisk {
	current: string;
	backend: IDiskBankEnd;
	ready: Promise<void>;
	clipboard: IClipboard;
	_link: Link;
	_zip: Zip;
	_watch: Watch;
	_sync: SyncProxy;
	get sync(): SyncProxy;
	_update: UpdateManager;
	static instance: Disk;
	enableSync: boolean;
	constructor({ enableSync, }?: IDiskOption);
	initSync(): Promise<void>;
	static initSync(): Promise<void>;
	_initSyncAlone(enableSync: boolean): Promise<void>;
	private init;
	fmtPath(path: string): string;
	size(path?: string): Promise<number>;
	cd(path: string): Promise<boolean>;
	isDir(path: string): Promise<boolean>;
	getType(path: string): Promise<IFileType>;
	pwd(): string;
	copy(files: string | string[]): Promise<boolean>;
	cut(files: string | string[]): Promise<boolean>;
	_addToClipboard(files: string | string[], isCut?: boolean): boolean;
	move(source: string, target: string, onFinalName?: (v: string) => void): Promise<string>;
	rename(path: string, name: string, onFinalName?: (v: string) => void): Promise<string>;
	paste(targetDir: string, renameMap?: Record<string, string>, onFinalName?: (map: Record<string, string>) => void): Promise<string>;
	pasteBase(targetDir: string, clipboard: IClipboard, renameMap?: Record<string, string>, onFinalName?: (map: Record<string, string>) => void): Promise<string>;
	copySingle(source: string, target: string): Promise<boolean>;
	traverseContent(path: string, callback: (path: string, content: Promise<Uint8Array | null>, name: string) => IPromiseMaybe<void>): Promise<void>;
	traverse(path: string, callback: (data: {
		path: string;
		parent: string;
		name: string;
	}) => void): Promise<void>;
	readText(path: string): Promise<string | null>;
	read(path: string): Promise<Uint8Array | null>;
	write(path: string, data: Uint8Array): Promise<boolean>;
	append(path: string, data: Uint8Array): Promise<boolean>;
	remove(path: string): Promise<boolean>;
	stat(path: string, recursive?: boolean): Promise<IFileStats>;
	_transStat({ size, type }: Pick<IFileStats, "type" | "size">): IFileStats;
	exist(path: string): Promise<boolean>;
	ls(path?: string): Promise<string[] | null>;
	createFile(path: string, content?: Uint8Array | undefined, opt?: ICreateOpt): Promise<boolean>;
	createDir(path: string, opt?: ICreateOpt): Promise<boolean>;
	_create(path: string, content?: Uint8Array | undefined, { overwrite, ensure }?: ICreateOpt, isDir?: boolean): Promise<boolean>;
	createLink(path: string, target: string, opt?: ICreateOpt): Promise<boolean>;
	zip(...args: Parameters<Zip["zip"]>): Promise<{
		success: boolean;
		info: string;
	}>;
	unzip(...args: Parameters<Zip["unzip"]>): Promise<{
		path: string;
		isDir: boolean;
	}[]>;
	isZip(...args: Parameters<Zip["isZip"]>): Promise<boolean>;
	watch(...args: Parameters<Watch["watch"]>): FSWatcher;
	watchFile(...args: Parameters<Watch["watchFile"]>): void;
	unwatchFile(...args: Parameters<Watch["unwatchFile"]>): void;
	clear(): Promise<void>;
	ensureParentPath(path: string): Promise<void>;
	_ensureParentPath(path: string): Promise<void>;
	createFileContent(content: string, type?: IFileType): Uint8Array<ArrayBufferLike>;
}
export declare function initDisk(opt?: IDiskOption): Promise<Disk>;
export declare const pt: NodePath;
export declare function splitPath(path: string): [
	string[],
	string
];
export declare function clearPath(path: string, tail?: boolean): string;
export declare function getParentPath(path: any): string;
export declare function getFileName(path: string): string;
export declare function getFileExt(path: string): string;
export declare function handlePasteFileNames(source: string[], // 复制的完整路径
targetDir: string, // 粘贴目标目录的完整路径
current: string[], // 当前文件夹所有文件名
renameMap?: Record<string, string>): Record<string, string>;
export declare function renameWhenConflict(name: string, set: Set<string>): string;
/**
 * input: /a/b, /a/b/c/d.js
 * output: /a/b/c
 */
export declare function extractSubDir(target: string, filePath: string): string;
export declare class CMD {
	static instance: CMD;
	disk: Disk;
	ready: Promise<void>;
	constructor(enableSync?: boolean);
	ls(path?: string): Promise<string[] | null>;
	cd(path: string): Promise<boolean>;
	pwd(): string;
	touch(path: string): Promise<boolean>;
	mkdir(path: string): Promise<boolean>;
	rmdir(path: string): Promise<boolean>;
	cp(src: string, dest: string): Promise<boolean>;
	mv(src: string, dest: string): Promise<string>;
	rm(path: string): Promise<boolean>;
	cat(path: string): Promise<string | null>;
	more(path: string): Promise<string | null>;
	less(path: string): Promise<string | null>;
	head(path: string, line: number): Promise<string>;
	tail(path: string, line: number): Promise<string>;
	grep(path: string, reg: string | RegExp): Promise<string[]>;
	find(path: string, { name, type }?: {
		name?: string | RegExp;
		type?: IFileType;
	}): Promise<string[]>;
	zip(files: string[], target?: string): Promise<{
		success: boolean;
		info: string;
	}>;
	unzip(path: string, target?: string): Promise<{
		path: string;
		isDir: boolean;
	}[]>;
	tar(files: string[], target?: string): Promise<{
		success: boolean;
		info: string;
	}>;
	du(path: string): Promise<number>;
}
export declare const createDirContent: () => {
	data: Uint8Array<ArrayBufferLike>;
	length: number;
};
export declare const createLinkContent: () => {
	data: Uint8Array<ArrayBufferLike>;
	length: number;
};
export declare function getTypeWithData(data: Uint8Array | null): IFileType;
export declare function createFileContent(type: IFileType, data?: Uint8Array | string): Uint8Array<ArrayBufferLike>;
// 这样写才会正确的生成dts
export const localforage: typeof _localforage = _localforage;
interface ICommand$1 extends ICommand<Disk> {
}
export interface ICommandDisk extends ICommand$1 {
}
export declare class CommandProvider implements ICommandProvider {
	methods: Parameters<ICommandProvider["onCommand"]>[1];
	cmd: CMD;
	name: string;
	thirdCommands: Record<string, ICommand>;
	private installCommand;
	constructor(enableSync: boolean, methods: Parameters<ICommandProvider["onCommand"]>[1]);
	getPwd(): string;
	get disk(): Disk;
	onCommand(content: string | ICommandInfo[]): Promise<string | boolean>;
	runSingleCommand(cur: ICommandInfo, prev: string, commands: ICommandInfo[]): Promise<string | boolean>;
	private handleEchoCmd;
	onTab(range: string, before: string): Promise<{
		line: string;
		result: string;
	}>;
	registerCommand(command: ICommand): IOprateResult;
	removeCommand(name: string): IOprateResult;
	private _loadCommands;
}
export declare const OpenUrlCommand: ICommand$1;
export declare const InnerCommands: ICommand[];
export declare function findInnerCommand(name: string): ICommand | null;

export {
	ICommandInfo,
	WebTerm,
	parseCommand,
	pt as path,
};

export {};