@static-suite/static-suite-data-server 0.0.1

package/dist/lib/store/diff/tracker.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tracker = void 0;
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("@lib/config");
+const logger_1 = require("@lib/utils/logger");
+const object_1 = require("@lib/utils/object");
+const includeIndex_1 = require("../include/includeIndex");
+/**
+ * A list of changed files with includes that have changed since last reset.
+ */
+const changedFiles = new Set();
+/**
+ * A flag to tell wether getChangedFiles() has been already called.
+ */
+let isChangedFilesInitialized = false;
+// Ensure several concurrent Data Servers use different files.
+let trackerFilepath = null;
+const getTrackerFilepath = () => {
+    if (!trackerFilepath) {
+        const dataDirHash = config_1.config.dataDir
+            .replace(/\//g, '-')
+            .replace(/([^a-zA-Z0-9-])/g, '')
+            .replace(/^-/g, '')
+            .replace(/-$/g, '');
+        trackerFilepath = `${os_1.default.homedir()}/.static-suite/data-server/${dataDirHash}/tracker.json`;
+    }
+    return trackerFilepath;
+};
+exports.tracker = {
+    trackChangedFile(relativeFilepath) {
+        // Add parents.
+        includeIndex_1.includeIndex
+            .getParents(relativeFilepath)
+            .forEach((parentRelativeFilepath) => {
+            changedFiles.add(parentRelativeFilepath);
+        });
+        // Add the passed file.
+        changedFiles.add(relativeFilepath);
+        // Store memory data into disk
+        const trackerFile = getTrackerFilepath();
+        const dataToStore = JSON.stringify({ changedFiles: (0, object_1.jsonify)(changedFiles) });
+        try {
+            if (!fs_1.default.existsSync(trackerFile)) {
+                fs_1.default.mkdirSync(path_1.default.dirname(trackerFile), { recursive: true });
+            }
+            fs_1.default.writeFileSync(trackerFile, dataToStore);
+        }
+        catch (e) {
+            logger_1.logger.error(`Error writing tracker file located at "${trackerFile}": ${e}`);
+        }
+    },
+    getChangedFiles: () => {
+        const trackerFile = getTrackerFilepath();
+        // The first time this function is executed (after Data Server is started for the first time),
+        // it tries to get changed files from previously stored value on disk.
+        if (!isChangedFilesInitialized && fs_1.default.existsSync(trackerFile)) {
+            try {
+                const trackerFileData = JSON.parse(fs_1.default.readFileSync(trackerFile).toString().trim());
+                isChangedFilesInitialized = true;
+                trackerFileData.changedFiles?.forEach((changedFile) => changedFiles.add(changedFile));
+            }
+            catch (e) {
+                logger_1.logger.error(`Error reading tracker file located at "${trackerFile}": ${e}`);
+            }
+        }
+        return Array.from(changedFiles);
+    },
+    reset: () => {
+        changedFiles.clear();
+        // Delete tracker file.
+        const trackerFile = getTrackerFilepath();
+        if (fs_1.default.existsSync(trackerFile)) {
+            fs_1.default.unlinkSync(trackerFile);
+        }
+    },
+};

package/dist/lib/store/diff/tracker.types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Track changed files affected by includes.
+ */
+export declare type Tracker = {
+    /**
+     * Gets a set of changed files from a file and adds them to a temporary stack.
+     *
+     * @remarks
+     * Between two builds, stored data can be mutated when dataDirManager::update() runs. That
+     * creates a problem when an include or file is removed, since once store is updated we cannot
+     * go back in time to track past changes. To avoid this, track changes files whenever store
+     * is updated.
+     *
+     * This function only tracks changed files affected by static includes. There is no need to track
+     * intermediate changes in query results, since they are evaluated on demand.
+     *
+     * @param relativeFilepath - Relative file path, inside dataDir, to the file to be processed.
+     */
+    trackChangedFile(relativeFilepath: string): void;
+    /**
+     * Gets the current set of changed files.
+     *
+     * @returns an array of changed files.
+     */
+    getChangedFiles(): string[];
+    /**
+     * Resets current set of changed files.
+     */
+    reset(): void;
+};
+//# sourceMappingURL=tracker.types.d.ts.map

package/dist/lib/store/diff/tracker.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/diff/tracker.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,OAAO,GAAG;IACpB;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAEjD;;;;OAIG;IACH,eAAe,IAAI,MAAM,EAAE,CAAC;IAE5B;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;CACf,CAAC"}

package/dist/lib/store/diff/tracker.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/dump/dumpManager.d.ts

@@ -0,0 +1,3 @@
+import { DumpManager } from './dumpManager.types';
+export declare const dumpManager: DumpManager;
+//# sourceMappingURL=dumpManager.d.ts.map

package/dist/lib/store/dump/dumpManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dumpManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dump/dumpManager.ts"],"names":[],"mappings":"AAUA,OAAO,EAAQ,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAqIxD,eAAO,MAAM,WAAW,EAAE,WA2FzB,CAAC"}

package/dist/lib/store/dump/dumpManager.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dumpManager = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const microtime_1 = __importDefault(require("microtime"));
+const logger_1 = require("@lib/utils/logger");
+const object_1 = require("@lib/utils/object");
+const fs_2 = require("@lib/utils/fs");
+const config_1 = require("@lib/config");
+const store_1 = require("@lib/store");
+const diffManager_1 = require("../diff/diffManager");
+const hook_1 = require("../hook");
+const removeEmptyDirsUpwards = (dir) => {
+    const isEmpty = fs_1.default.readdirSync(dir).length === 0;
+    if (isEmpty) {
+        try {
+            fs_1.default.rmdirSync(dir);
+        }
+        catch (e) {
+            logger_1.logger.debug(`Error deleting empty directory "${dir}": ${e}`);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        removeEmptyDirsUpwards(path_1.default.dirname(dir));
+    }
+};
+const storeUpdatedFiles = (diff, dump, dumpDir) => {
+    diff.updated.forEach(relativeFilepath => {
+        const storeFileContentData = store_1.store.data.get(relativeFilepath);
+        if (storeFileContentData) {
+            const absoluteFilepathInDumpDir = `${dumpDir}/${relativeFilepath}`;
+            try {
+                // Create parent directories if they are missing.
+                const dir = path_1.default.dirname(absoluteFilepathInDumpDir);
+                if (!fs_1.default.existsSync(dir)) {
+                    fs_1.default.mkdirSync(dir, { recursive: true });
+                }
+                // If store data is an object, stringify it to execute its
+                // queries and resolve its includes.
+                const isJson = (0, fs_2.isJsonFile)(relativeFilepath);
+                const storeFileContentString = isJson
+                    ? JSON.stringify(storeFileContentData)
+                    : storeFileContentData;
+                // Before overwriting a file, check it has changed.
+                let needsSave = true;
+                let oldPublicUrl = null;
+                const newPublicUrl = storeFileContentData.data?.content?.url?.path || null;
+                if (fs_1.default.existsSync(absoluteFilepathInDumpDir)) {
+                    const dumpFileContentString = (0, fs_2.readFile)(absoluteFilepathInDumpDir);
+                    if (storeFileContentString === dumpFileContentString) {
+                        // No need to save it, file has not changed.
+                        needsSave = false;
+                    }
+                    else if (isJson && dumpFileContentString) {
+                        // Get old public URL before it changes on disk.
+                        oldPublicUrl =
+                            JSON.parse(dumpFileContentString)?.data?.content?.url?.path ||
+                                null;
+                        /*
+                        fs.renameSync(
+                          absoluteFilepathInDumpDir,
+                          absoluteFilepathInDumpDir.replace('.json', '.2.json'),
+                        );
+                        */
+                    }
+                }
+                if (needsSave) {
+                    // Save it.
+                    fs_1.default.writeFileSync(absoluteFilepathInDumpDir, storeFileContentString);
+                    // Mark it as updated.
+                    dump.updated.set(relativeFilepath, {
+                        oldPublicUrl,
+                        newPublicUrl,
+                    });
+                }
+            }
+            catch (e) {
+                logger_1.logger.error(`Dump: error writing file "${absoluteFilepathInDumpDir}": ${e}`);
+            }
+        }
+        else {
+            logger_1.logger.error(`Dump: store data for file "${relativeFilepath}" not found.`);
+        }
+    });
+};
+const removeDeletedFiles = (diff, dump, dumpDir) => {
+    diff.deleted.forEach(relativeFilepath => {
+        const absoluteFilepath = `${dumpDir}/${relativeFilepath}`;
+        try {
+            if (fs_1.default.existsSync(absoluteFilepath)) {
+                // Get old public URLs before they change on disk.
+                const dumpContent = (0, fs_2.getFileContent)(absoluteFilepath);
+                const oldPublicUrl = dumpContent.json?.data?.content?.url?.path;
+                // Delete it.
+                fs_1.default.unlinkSync(absoluteFilepath);
+                // Mark it as deleted.
+                dump.deleted.set(relativeFilepath, {
+                    oldPublicUrl,
+                    newPublicUrl: null,
+                });
+            }
+        }
+        catch (e) {
+            logger_1.logger.error(`Dump: error deleting file "${absoluteFilepath}": ${e}`);
+        }
+    });
+};
+const storeDumpMetadata = (metadataFilepath, dump, diffResetDate) => {
+    let currentDumpMetadata = [];
+    try {
+        currentDumpMetadata = JSON.parse(fs_1.default.readFileSync(metadataFilepath).toString());
+    }
+    catch (e) {
+        currentDumpMetadata = [];
+    }
+    currentDumpMetadata.push((0, object_1.jsonify)(dump));
+    try {
+        const currentDumpMetadataString = JSON.stringify(currentDumpMetadata);
+        fs_1.default.writeFileSync(metadataFilepath, currentDumpMetadataString);
+        // Resetting the diff must happen when dump metadata is successfully
+        // stored into disk.
+        diffManager_1.diffManager.reset(diffResetDate);
+    }
+    catch (e) {
+        logger_1.logger.error(`Dump: error saving dump metadata to "${metadataFilepath}": ${e}`);
+    }
+};
+exports.dumpManager = {
+    dump(options = { incremental: true }) {
+        const startDate = microtime_1.default.now();
+        // Create a diff reset date just before consuming a diff.
+        const diffResetDate = new Date();
+        const diff = diffManager_1.diffManager.getDiff({ incremental: options.incremental });
+        // Diff data is processed and transformed into a dump object.
+        let dump = {
+            since: diff.since,
+            updated: new Map(),
+            deleted: new Map(),
+        };
+        if (config_1.config.dumpDir) {
+            const dumpDir = `${config_1.config.dumpDir}/files`;
+            const metadataFilepath = `${config_1.config.dumpDir}/metadata.json`;
+            if (diff.updated.size || diff.deleted.size) {
+                // Store updated files.
+                storeUpdatedFiles(diff, dump, dumpDir);
+                // Remove deleted files.
+                removeDeletedFiles(diff, dump, dumpDir);
+                // Invoke "onDumpCreate" hook.
+                dump = hook_1.hookManager.invokeOnDumpCreate(dump);
+                const execTimeMs = (microtime_1.default.now() - startDate) / 1000;
+                dump.execTimeMs = execTimeMs;
+                // Merge and store dump metadata if any.
+                if (dump.updated.size || dump.deleted.size) {
+                    storeDumpMetadata(metadataFilepath, dump, diffResetDate);
+                    logger_1.logger.info(`Dump created in ${execTimeMs} ms. Updated: ${dump.updated.size} / Deleted: ${dump.deleted.size}`);
+                    // Log dump if not empty
+                    if (dump.updated.size || dump.deleted.size) {
+                        logger_1.logger.debug(`Dump: "${JSON.stringify((0, object_1.jsonify)(dump))}"`);
+                    }
+                }
+                else {
+                    // Resetting the diff must happen when no other operations are pending.
+                    diffManager_1.diffManager.reset(diffResetDate);
+                    logger_1.logger.info(`Dump done in ${execTimeMs} ms without changes stored into disk.`);
+                }
+            }
+            else {
+                logger_1.logger.info('Dump not stored into disk due to an empty diff.');
+            }
+        }
+        else {
+            logger_1.logger.error('"dumpDir" option not provided. Dump cannot be executed.');
+        }
+        return dump;
+    },
+    reset(timestamp) {
+        if (config_1.config.dumpDir) {
+            const metadataFilepath = `${config_1.config.dumpDir}/metadata.json`;
+            const metadata = JSON.parse(fs_1.default.existsSync(metadataFilepath)
+                ? fs_1.default.readFileSync(metadataFilepath).toString()
+                : '[]');
+            // Remove any dump data older that timestamp
+            const resetMetadata = metadata.filter((dump) => dump.since > timestamp);
+            logger_1.logger.debug(`Dump reset : "${JSON.stringify(resetMetadata)}"`);
+            try {
+                fs_1.default.writeFileSync(metadataFilepath, JSON.stringify(resetMetadata));
+            }
+            catch (e) {
+                logger_1.logger.error(`Dump: error resetting dump metadata to "${metadataFilepath}": ${e}`);
+            }
+        }
+        else {
+            logger_1.logger.error('"dumpDir" option not provided. Dump reset cannot be executed.');
+        }
+    },
+};

package/dist/lib/store/dump/dumpManager.types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Service that dumps resolved data (with resolved includes) into a dump directory.
+ */
+export declare type DumpManager = {
+    /**
+     * Dump resolved data (with resolved includes) into a dump directory.
+     *
+     * @remarks
+     * Raw data stored in Data Server does not resolve its includes until
+     * each file is consumed (and therefore stringified). A dump consumes
+     * that raw data and stores it in a directory, along its metadata
+     * (a list of changed/deleted files), so a later process can store
+     * those changes in another service like AWS S3.
+     *
+     * @param options - Configuration options
+     */
+    dump(options?: {
+        incremental: boolean;
+    }): Dump;
+    /**
+     * Reset dump metadata.
+     *
+     * @remarks
+     * Resets dump metadata, removing any dump information older than the passed timestamp.
+     *
+     * @param timestamp - Timestamp
+     */
+    reset(timestamp: number): void;
+};
+/**
+ * A group of files to by dumped to dump directory.
+ */
+export declare type Dump = {
+    /**
+     * Timestamp in milliseconds.
+     */
+    since: number;
+    /**
+     * A list of updated files, keyed by file path. Its value is an object with two keys,
+     * old public URL and new public URL (the value stored at data.content.url.path) before
+     * and after updating file in dumpDir.
+     */
+    updated: Map<string, {
+        oldPublicUrl: string | null;
+        newPublicUrl: string | null;
+    }>;
+    /**
+     * A list of deleted files, keyed by file path. Its value is an object with two keys,
+     * old public URL and new public URL (the value stored at data.content.url.path) before
+     * and after updating file in dumpDir. New public URL is always null, since file is
+     * deleted. We keep the same structure for both updated and deleted items.
+     */
+    deleted: Map<string, {
+        oldPublicUrl: string | null;
+        newPublicUrl: null;
+    }>;
+    /**
+     * Optional execution time taken by the dump, in milliseconds.
+     */
+    execTimeMs?: number;
+};
+//# sourceMappingURL=dumpManager.types.d.ts.map

package/dist/lib/store/dump/dumpManager.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dumpManager.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dump/dumpManager.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,WAAW,GAAG;IACxB;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAE/C;;;;;;;OAOG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC,CAAC;AAEF;;GAEG;AACH,oBAAY,IAAI,GAAG;IACjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;;;OAIG;IACH,OAAO,EAAE,GAAG,CACV,MAAM,EACN;QAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAC7D,CAAC;IAEF;;;;;OAKG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,YAAY,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAE1E;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/lib/store/dump/dumpManager.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/dump/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dumpManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/store/dump/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dump/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/lib/store/dump/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dumpManager"), exports);

package/dist/lib/store/hook/hook.types.d.ts

@@ -0,0 +1,205 @@
+import { ConfigOptions } from '@lib/config/config.types';
+import { Store } from '@lib/store/store.types';
+import { FileType } from '@lib/utils/fs/fs.types';
+import { DependencyTagger } from '../dependency/dependency.types';
+import { Dump } from '../dump/dumpManager.types';
+import { ChangedFiles } from '../workDir/workDir.types';
+/**
+ * A manager for a group of user-land modules.
+ *
+ * @typeParam ModuleType - The type of module being managed.
+ */
+export declare type HookManager = {
+    reset(): void;
+    invokeOnStoreLoadStart(): void;
+    invokeOnProcessFile(options: FileHookOptions): FileType;
+    invokeOnStoreItemAdd(options: FileHookOptions): void;
+    invokeOnStoreLoadDone(): void;
+    invokeOnStoreChangeStart(changedFiles: ChangedFiles): void;
+    invokeOnStoreItemBeforeUpdate(options: FileHookOptions): void;
+    invokeOnStoreItemAfterUpdate(options: FileHookOptions): void;
+    invokeOnStoreItemDelete(options: FileHookOptions): void;
+    invokeOnStoreChangeDone(changedFiles: ChangedFiles): void;
+    invokeOnDumpCreate(dump: Dump): Dump;
+};
+/**
+ * Options passed to an onModuleLoad hook.
+ */
+export interface OnModuleLoadHookOptions {
+    /**
+     * Configuration options.
+     */
+    config: ConfigOptions;
+    /**
+     * The data store.
+     */
+    store: Store;
+}
+/**
+ * Options passed to a hook.
+ *
+ * @remarks
+ * Since hooks are user-land modules, they do not have access to configuration
+ * or any other part of the Data Server. All data they need to function must be
+ * passed as parameters.
+ */
+export interface BaseHookOptions {
+    /**
+     * The data store.
+     */
+    store: Store;
+    /**
+     * The dependency tagger service.
+     */
+    dependencyTagger: DependencyTagger;
+}
+/**
+ * Options passed to a file hook.
+ */
+export interface FileHookOptions {
+    /**
+     * Relative file path inside the data dir.
+     */
+    relativeFilepath: string;
+    /**
+     * File contents, an object with "raw" and "json" members.
+     */
+    fileContent: FileType;
+}
+/**
+ * Full options passed to a hook.
+ */
+export interface FullHookOptions extends BaseHookOptions, FileHookOptions {
+}
+export interface ChangedFilesHookOptions extends BaseHookOptions {
+    /**
+     * A group of changed files in Static Suite's data dir.
+     */
+    changedFiles: ChangedFiles;
+}
+export interface OnDumpHookOptions {
+    /**
+     * Path to the dump directory.
+     */
+    dumpDir: string;
+    /**
+     * The data store.
+     */
+    store: Store;
+    /**
+     * The dump to be processed.
+     */
+    dump: Dump;
+}
+/**
+ * A module that defines several hooks.
+ */
+export declare type HookModule = {
+    /**
+     * A hook executed when a hook module is loaded or reloaded.
+     *
+     * @remarks
+     * This hook is aimed at bootstrapping some data structure, or establishing some connection
+     * to an external system before other hooks are run.
+     */
+    onModuleLoad?(options: OnModuleLoadHookOptions): void;
+    /**
+     * A hook executed before the store starts loading.
+     *
+     * @remarks
+     * This hook is aimed at bootstrapping some data structure, or establishing some connection
+     * to an external system before other hooks are run.
+     *
+     * @param options - An object with options passed to the hook. @see {@link HookOptions}
+     */
+    onStoreLoadStart?(options: BaseHookOptions): void;
+    /**
+     * A hook executed after a file is read from disk, before adding it to the store.
+     *
+     * @remarks
+     * This hook is aimed at altering the contents of the file before it being added to the store.
+     *
+     * @param options - An object with options passed to the hook. @see {@link FileHookOptions}
+     *
+     * @returns The file contents, and object with "raw" and "json" members.
+     */
+    onProcessFile?(options: FullHookOptions): FileType;
+    /**
+     * A hook executed after a file is added into the store.
+     *
+     * @remarks
+     * This hook is aimed at adding some information to the store, e.g.- indexing all contents
+     * by their taxonomy.
+     *
+     * @param options - An object with options passed to the hook. @see {@link FileHookOptions}
+     */
+    onStoreItemAdd?(options: FullHookOptions): void;
+    /**
+     * A hook executed after the store finishes loading.
+     *
+     * @remarks
+     * This hook is aimed at adding some final information to the store, e.g.- counting all images, etc
+     *
+     * @param options - An object with options passed to the hook. @see {@link HookOptions}
+     */
+    onStoreLoadDone?(options: BaseHookOptions): void;
+    /**
+     * A hook executed before the store starts updating.
+     *
+     * @remarks
+     * This hook is aimed at bootstrapping or updating some data structure
+     * before a set of update/delete operations starts.
+     *
+     * @param options - An object with options passed to the hook. @see {@link HookOptions}
+     */
+    onStoreChangeStart?(options: ChangedFilesHookOptions): void;
+    /**
+     * A hook executed before a file is updated in the store.
+     *
+     * @remarks
+     * This hook is aimed at adding some information to the store, e.g.- indexing all contents
+     * by their taxonomy.
+     *
+     * @param options - An object with options passed to the hook. @see {@link FileHookOptions}
+     */
+    onStoreItemBeforeUpdate?(options: FullHookOptions): void;
+    /**
+     * A hook executed after a file is updated in the store.
+     *
+     * @remarks
+     * This hook is aimed at adding some information to the store, e.g.- indexing all contents
+     * by their taxonomy.
+     *
+     * @param options - An object with options passed to the hook. @see {@link FileHookOptions}
+     */
+    onStoreItemAfterUpdate?(options: FullHookOptions): void;
+    /**
+     * A hook executed after a file is deleted from the store.
+     *
+     * @remarks
+     * This hook is aimed at reverting the actions taken in storeAdd hook, e.g.- removing a file
+     * from a taxonomy index.
+     *
+     * @param options - An object with options passed to the hook. @see {@link FileHookOptions}
+     */
+    onStoreItemDelete?(options: FullHookOptions): void;
+    /**
+     * A hook executed after the store ends updating.
+     *
+     * @remarks
+     * This hook is run after a set of update/delete operations finishes.
+     *
+     * @param options - An object with options passed to the hook. @see {@link HookOptions}
+     */
+    onStoreChangeDone?(options: ChangedFilesHookOptions): void;
+    /**
+     * A hook executed after a dump object is created.
+     *
+     * @remarks
+     * This hook can alter the contents of the dump being saved, and add/remove items.
+     *
+     * @param options - An object with options passed to the hook. @see {@link OnDumpHookOptions}
+     */
+    onDumpCreate?(options: OnDumpHookOptions): Dump;
+};
+//# sourceMappingURL=hook.types.d.ts.map

package/dist/lib/store/hook/hook.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/hook/hook.types.ts"],"names":[],"mappings":"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"}

package/dist/lib/store/hook/hook.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/store/hook/hookManager.d.ts

@@ -0,0 +1,6 @@
+import { HookManager } from './hook.types';
+/**
+ * A specialized hook manager with invoke helpers for all hooks
+ */
+export declare const hookManager: HookManager;
+//# sourceMappingURL=hookManager.d.ts.map

package/dist/lib/store/hook/hookManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hookManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/hook/hookManager.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAc,MAAM,cAAc,CAAC;AAYvD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,WA+JzB,CAAC"}