@types/file-entry-cache

property changedFiles

readonly changedFiles: string[];

property notChangedFiles

readonly notChangedFiles: string[];

property notFoundFiles

readonly notFoundFiles: string[];

property changed

readonly changed?: boolean | undefined;

property err

readonly err?: Error | undefined;

property key

readonly key: string;

property meta

readonly meta?:
    | {
          readonly size?: number | undefined;
          readonly mtime?: number | undefined;
          readonly hash?: string | undefined;
      }
    | undefined;

property notFound

readonly notFound: boolean;

property cache

cache: object;

• the flat cache storage used to persist the metadata of the `files

method analyzeFiles

analyzeFiles: (files?: string[]) => AnalyzedFilesInfo;

• given an array of file paths it return and object with three arrays: - changedFiles: Files that changed since previous run - notChangedFiles: Files that haven't change - notFoundFiles: Files that were not found, probably deleted

method deleteCacheFile

deleteCacheFile: () => void;

• Delete the cache file from the disk

method destroy

destroy: () => void;

• remove the cache from the file and clear the memory cache

method getFileDescriptor

getFileDescriptor: (file: string) => FileDescriptor;

method getHash

getHash: (buffer: Buffer) => string;

• Given a buffer, calculate md5 hash of its content.

method getUpdatedFiles

getUpdatedFiles: (files?: string[]) => string[];

• Return the list o the files that changed compared against the ones stored in the cache

method hasFileChanged

hasFileChanged: (file: string) => boolean;

• Return whether or not a file has changed since last time reconcile was called

method normalizeEntries

normalizeEntries: (files?: string[]) => FileDescriptor[];

• return the list of file

method reconcile

reconcile: (noPrune?: boolean) => void;

• Sync the files and persist them to the cache

method removeEntry

removeEntry: (entryName: string) => void;

• Remove an entry from the file-entry-cache. Useful to force the file to still be considered modified the next time the process is run