@e-mc/file-manager

* NodeJS 18.20.5 LTS
* ES2022

General Usage

* Read the Docs

Interface

* View Source

``typescript
import type { ChecksumValue, DataSource, IncrementalMatch, TaskAction } from "./squared";

import type { DocumentConstructor, HostConstructor, ICloud, ICompress, IDocument, IHost, IImage, IModule, IRequest, ITask, IWatch, ImageConstructor, TaskConstructor, WatchConstructor } from "./index";
import type { ExternalAsset, FileCommand, FileData, IFileThread, OutputFinalize } from "./asset";
import type { IPermission, PermissionReadWrite } from "./core";
import type { AssetContentOptions, CheckHashOptions, ChecksumOptions, DeleteFileAddendum, FileOutput, FinalizeResult, FindAssetOptions, IHttpDiskCache, IHttpMemoryCache, ImageMimeMap, InstallData, PostFinalizeCallback, ReplaceOptions } from "./filemanager";
import type { ExecCommand } from "./logger";
import type { CopyFileOptions, CreateDirOptions, DeleteFileOptions, MoveFileOptions, ReadFileOptions, RemoveDirOptions, WriteFileOptions } from "./module";
import type { RequestData, Settings } from "./node";
import type { Aria2Options, BufferFormat, OpenOptions } from "./request";
import type { CloudModule, CompressModule, DbModule, DocumentModule, HttpConnectSettings, HttpMemorySettings, ImageModule, RequestModule, TaskModule, WatchModule } from "./settings";

import type { SpawnOptions } from "node:child_process";
import type { NoParamCallback } from "node:fs";

interface IFileManager extends IHost, Set {
processTimeout: number;
Request: IRequest;
Document: InstallData, DocumentConstructor>[];
Task: InstallData[];
Image: Map | null;
Cloud: ICloud | null;
Watch: WatchInstance | null;
Compress: ICompress | null;
readonly documentAssets: ExternalAsset[];
readonly taskAssets: (ExternalAsset & Required)[];
readonly dataSourceItems: DataSource[];
readonly files: Set;
readonly filesQueued: Set;
readonly filesToRemove: Set;
readonly filesToCompare: Map;
readonly contentToAppend: Map;
readonly contentToReplace: Map;
readonly processing: IFileThread[];
readonly fetchedAssets: ExternalAsset[];
readonly copiedAssets: ExternalAsset[];
readonly emptyDir: Set;
readonly cacheToDisk: IHttpDiskCache;
readonly cacheToMemory: IHttpMemoryCache;
install(name: "document", handler: string, module?: DocumentModule, ...args: unknown[]): IDocument | undefined;
install(name: "document", target: DocumentConstructor, module?: DocumentModule, ...args: unknown[]): IDocument | undefined;
install(name: "task", handler: string, module?: TaskModule, ...args: unknown[]): ITask | undefined;
install(name: "task", target: TaskConstructor, module?: TaskModule, ...args: unknown[]): ITask | undefined;
install(name: "cloud", handler: string, module?: CloudModule, ...args: unknown[]): ICloud | undefined;
install(name: "cloud", module?: CloudModule, ...args: unknown[]): ICloud | undefined;
install(name: "image", handler: string, module?: ImageModule, ...args: unknown[]): IImage | undefined;
install(name: "image", target: ImageConstructor, module?: ImageModule, ...args: unknown[]): IImage | undefined;
install(name: "image", targets: Map, module?: ImageModule): void;
install(name: "watch", handler: string, module?: WatchModule, ...args: unknown[]): IWatch | undefined;
install(name: "watch", target: WatchConstructor, module?: WatchModule, ...args: unknown[]): IWatch | undefined;
install(name: "watch", module: WatchModule): IWatch | undefined;
install(name: "compress", module?: CompressModule): ICompress | undefined;
install(name: string, ...args: unknown[]): IModule | undefined;
using(...items: ExternalAsset[] | [boolean, ...ExternalAsset[]]): this;
contains(item: ExternalAsset, condition?: (target: ExternalAsset) => boolean): boolean;
removeCwd(value: unknown): string;
findAsset(value: string | URL, instance?: IModule | FindAssetOptions): ExternalAsset | undefined;
removeAsset(file: ExternalAsset): boolean;
replace(file: ExternalAsset, replaceWith: string, mimeType: string | undefined): boolean;
replace(file: ExternalAsset, replaceWith: string, options?: ReplaceOptions): boolean;
rename(file: ExternalAsset, value: string): boolean;
performAsyncTask(): void;
removeAsyncTask(): void;
completeAsyncTask(err?: unknown, uri?: string, parent?: ExternalAsset, type?: number): void;
performFinalize(override?: boolean): void;
hasDocument(instance: IModule, document: string | string[] | undefined): boolean;
getDocumentAssets(instance: IModule, condition?: (target: ExternalAsset) => boolean): ExternalAsset[];
getDataSourceItems(instance: IModule, condition?: (target: DataSource) => boolean): DataSource[];
checkFilename(file: ExternalAsset, pathname?: string): string;
setLocalUri(file: ExternalAsset, replace?: boolean): FileOutput;
getLocalUri(data: FileData): string;
getMimeType(data: FileData): string;
openThread(instance: IModule, data: IFileThread, timeout?: number): boolean;
closeThread(instance: IModule | null, data: IFileThread, callback?: (...args: unknown[]) => void): boolean;
addProcessTimeout(instance: IModule, file: ExternalAsset, timeout: number): void;
removeProcessTimeout(instance: IModule, file: ExternalAsset): void;
getProcessTimeout(handler: InstallData): number;
clearProcessTimeout(): void;
scheduleTask(uri: string | URL, data: unknown, priority: number): Promise;
scheduleTask(uri: string | URL, data: unknown, thenCallback?: (...args: unknown[]) => unknown, catchCallback?: (...args: unknown[]) => unknown, priority?: number): Promise;
setTaskLimit(value: number): void;
addDownload(value: number | Buffer | string, encoding: BufferEncoding): number;
addDownload(value: number | Buffer | string, type?: number | BufferEncoding, encoding?: BufferEncoding): number;
getDownload(type?: number): [number, number];
checkHash(checksum: ChecksumValue, options: CheckHashOptions): boolean;
checkHash(checksum: ChecksumValue, data: Bufferable | null, uri: string | URL | undefined): boolean;
checkHash(checksum: ChecksumValue, data: Bufferable, options?: CheckHashOptions): boolean;
transformAsset(data: IFileThread, parent?: ExternalAsset, override?: boolean): Promise;
addCopy(data: FileCommand, saveAs?: string, replace?: boolean): string | undefined;
handleFilePermission(file: ExternalAsset): void;
findMime(file: ExternalAsset, rename?: boolean): Promise;
getUTF8String(file: ExternalAsset, uri?: string): string;
getBuffer(file: ExternalAsset, minStreamSize?: number): Promise | Buffer | null;
getCacheDir(url: string | URL, createDir?: boolean): string;
setAssetContent(file: ExternalAsset, content: string, options?: AssetContentOptions): string;
getAssetContent(file: ExternalAsset, content?: string): string | undefined;
writeBuffer(file: ExternalAsset, options?: WriteFileOptions): Buffer | null;
writeImage(document: string | string[], output: OutputFinalize): boolean;
compressFile(file: ExternalAsset, overwrite?: boolean): Promise;
fetchObject(uri: string | URL, format: BufferFormat): Promise