107 lines
3.2 KiB
TypeScript
107 lines
3.2 KiB
TypeScript
import { BinaryLike } from 'crypto';
|
|
|
|
interface MultiHashData {
|
|
"cid_sha2-256"?: string;
|
|
cid_sha1?: string;
|
|
cid_md5?: string;
|
|
"cid_sha3-256"?: string;
|
|
}
|
|
interface ComputeInterface {
|
|
computeMissingHash(filePath: string, metadata: MultiHashData): Promise<void>;
|
|
}
|
|
declare enum CID_ALGORITHM_CODES {
|
|
sha256 = 18,
|
|
sha1 = 17,
|
|
md5 = 213,
|
|
sha3_256 = 22
|
|
}
|
|
declare enum CID_ALGORITHM_NAMES {
|
|
sha256 = "cid_sha2-256",
|
|
sha1 = "cid_sha1",
|
|
md5 = "cid_md5",
|
|
sha3_256 = "cid_sha3-256"
|
|
}
|
|
declare enum CID_ALGORITHM {
|
|
sha256 = "sha2-256",
|
|
sha1 = "sha1",
|
|
md5 = "md5",
|
|
sha3_256 = "sha3-256"
|
|
}
|
|
|
|
declare class HashComputer implements ComputeInterface {
|
|
private targetHash;
|
|
private fileIDComputer;
|
|
constructor(targetHash: CID_ALGORITHM_NAMES[]);
|
|
computeMissingHash(filePath: string, metadata: MultiHashData): Promise<void>;
|
|
}
|
|
|
|
interface IndexLine extends Partial<Record<CID_ALGORITHM_NAMES, string>> {
|
|
path: string;
|
|
size: string;
|
|
mtime: string;
|
|
}
|
|
declare const INDEX_HEADERS: string[];
|
|
declare class HashIndexManager {
|
|
private filePath;
|
|
private targetHash;
|
|
private cache;
|
|
private intervalId;
|
|
private intervalTime;
|
|
private lastIndexFileSize;
|
|
private lastCacheFile;
|
|
private indexOpsInProgress;
|
|
private hasChanged;
|
|
private initialLoad;
|
|
constructor(filePath: string, targetHash?: CID_ALGORITHM_NAMES[]);
|
|
getCache(): Map<string, IndexLine>;
|
|
/**
|
|
* After init consseutively calls to this method will not reload the index
|
|
* @param autosave
|
|
*/
|
|
init(autosave?: boolean): Promise<any>;
|
|
checkCSVHeaders(csvContent: string): boolean;
|
|
start(): void;
|
|
stopAutoSave(): void;
|
|
private startAutoSave;
|
|
loadIndex(): Promise<IndexLine[]>;
|
|
private loadIndexFromCache;
|
|
private readCsv;
|
|
private saveCacheToFile;
|
|
getCidForFile(filePath: string, fileSize: number, mtime: string): IndexLine;
|
|
addFileCid(filePath: string, fileSize: number, mtime: string, hashs: Partial<Record<CID_ALGORITHM_NAMES, string>>): void;
|
|
}
|
|
|
|
declare class ComputeHashIndexCache implements ComputeInterface {
|
|
private targetHash;
|
|
hashIndexManager: HashIndexManager;
|
|
hashComputer: HashComputer;
|
|
constructor(indexFilePath: string, targetHash?: CID_ALGORITHM_NAMES[]);
|
|
computeMissingHash(filePath: string, metadata: MultiHashData): Promise<void>;
|
|
}
|
|
|
|
declare function existsAsync(filePath: string): Promise<boolean>;
|
|
|
|
declare class FileIDComputer {
|
|
private piscina;
|
|
constructor();
|
|
/**
|
|
* Compute the CIDs of a file using specific algorithms
|
|
* @param filePath The path to the file
|
|
* @param algorithms Array of algorithms ('sha256', 'sha1')
|
|
* @returns Array of CIDs (in the order of the algorithms)
|
|
*/
|
|
computeCIDs(filePath: string, algorithms: CID_ALGORITHM_NAMES[]): Promise<string[]>;
|
|
}
|
|
|
|
interface SimpleHash {
|
|
update(data: BinaryLike): any;
|
|
digest(): Buffer;
|
|
}
|
|
|
|
interface Properties {
|
|
TARGET_HASHES: string;
|
|
INDEX_FILE_PATH: string;
|
|
}
|
|
|
|
export { CID_ALGORITHM, CID_ALGORITHM_CODES, CID_ALGORITHM_NAMES, ComputeHashIndexCache, type ComputeInterface, FileIDComputer, HashComputer, HashIndexManager, INDEX_HEADERS, type MultiHashData, type Properties, type SimpleHash, existsAsync };
|