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

package/dist/lib/store/include/parsers/queryIncludeParser.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryIncludeParser = void 0;
+const config_1 = require("@lib/config");
+const dataServer_types_1 = require("@lib/dataServer.types");
+const query_1 = require("@lib/query");
+const query_types_1 = require("@lib/query/query.types");
+const object_1 = require("@lib/utils/object");
+const aliasWithoutTypeIncludeParser_1 = require("./types/aliasWithoutTypeIncludeParser");
+/**
+ * Parses query includes.
+ *
+ * @remarks
+ * Instead of executing a query and adding its result to a JSON file,
+ * create a Proxy so queries are only executed when they are consumed,
+ * in a Just-In-Time way.
+ */
+const queryIncludeParser = ({ host, includePath, }) => {
+    const queryDefinition = (0, object_1.getObjValue)(host, includePath);
+    if (!queryDefinition) {
+        return;
+    }
+    // Execute the query when the "data" property is accessed.
+    const proxyHandler = {
+        get: (target, prop) => {
+            if (prop === 'data') {
+                const queryResponse = query_1.queryRunner.run(queryDefinition);
+                if ((0, query_types_1.isQueryErrorResponse)(queryResponse)) {
+                    return config_1.config.runMode === dataServer_types_1.RunMode.DEV
+                        ? `${queryResponse.error} (message visible only in run mode DEV)`
+                        : null;
+                }
+                return queryResponse.data;
+            }
+            return undefined;
+        },
+    };
+    const target = new Proxy({ data: null }, proxyHandler);
+    const mountPath = includePath.split('.');
+    const includeKey = mountPath.pop();
+    if (includeKey) {
+        (0, aliasWithoutTypeIncludeParser_1.aliasWithoutTypeIncludeParser)({ host, target, mountPath, includeKey }, 'query');
+    }
+};
+exports.queryIncludeParser = queryIncludeParser;

package/dist/lib/store/include/parsers/types/aliasIncludeParser.d.ts

@@ -0,0 +1,3 @@
+import { GenericIncludeParserOptions } from '@lib/store/include/includeParser.types';
+export declare const aliasIncludeParser: ({ host, target, mountPath, includeKey, }: GenericIncludeParserOptions) => void;
+//# sourceMappingURL=aliasIncludeParser.d.ts.map

package/dist/lib/store/include/parsers/types/aliasIncludeParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliasIncludeParser.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/store/include/parsers/types/aliasIncludeParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAGrF,eAAO,MAAM,kBAAkB,6CAK5B,2BAA2B,KAAG,IAIhC,CAAC"}

package/dist/lib/store/include/parsers/types/aliasIncludeParser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliasIncludeParser = void 0;
+const object_1 = require("@lib/utils/object");
+const aliasIncludeParser = ({ host, target, mountPath, includeKey, }) => {
+    const mountPoint = (0, object_1.getObjValue)(host, mountPath);
+    mountPoint[includeKey.replace('Include', '')] = target;
+    delete mountPoint[includeKey];
+};
+exports.aliasIncludeParser = aliasIncludeParser;

package/dist/lib/store/include/parsers/types/aliasWithoutTypeIncludeParser.d.ts

@@ -0,0 +1,8 @@
+import { GenericIncludeParserOptions } from '@lib/store/include/includeParser.types';
+/**
+ *
+ * @param options - Object with options as defined in @see {@link IncludeParserOptions}
+ * @param type - Type of include (custom, query, etc)
+ */
+export declare const aliasWithoutTypeIncludeParser: ({ host, target, mountPath, includeKey }: GenericIncludeParserOptions, type: string) => void;
+//# sourceMappingURL=aliasWithoutTypeIncludeParser.d.ts.map

package/dist/lib/store/include/parsers/types/aliasWithoutTypeIncludeParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliasWithoutTypeIncludeParser.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/store/include/parsers/types/aliasWithoutTypeIncludeParser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,2BAA2B,EAAE,MAAM,wCAAwC,CAAC;AAErF;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,4CACC,2BAA2B,QAC9D,MAAM,KACX,IAWF,CAAC"}

package/dist/lib/store/include/parsers/types/aliasWithoutTypeIncludeParser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliasWithoutTypeIncludeParser = void 0;
+const object_1 = require("@lib/utils/object");
+/**
+ *
+ * @param options - Object with options as defined in @see {@link IncludeParserOptions}
+ * @param type - Type of include (custom, query, etc)
+ */
+const aliasWithoutTypeIncludeParser = ({ host, target, mountPath, includeKey }, type) => {
+    const mountPoint = (0, object_1.getObjValue)(host, mountPath);
+    const mountPointKey = includeKey.replace('Include', '') === type
+        ? type
+        : includeKey.replace(`${type.charAt(0).toUpperCase() + type.slice(1)}Include`, '');
+    mountPoint[mountPointKey] = target;
+    delete mountPoint[includeKey];
+};
+exports.aliasWithoutTypeIncludeParser = aliasWithoutTypeIncludeParser;

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

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

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

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

package/dist/lib/store/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("./store"), exports);

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

@@ -0,0 +1,7 @@
+import { Store } from './store.types';
+export declare const store: Store;
+/**
+ * Resets store and deletes all loaded data.
+ */
+export declare const resetStore: () => void;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/lib/store/store.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,KAAK,EAIN,MAAM,eAAe,CAAC;AAcvB,eAAO,MAAM,KAAK,EAAE,KAKnB,CAAC;AAkEF;;GAEG;AACH,eAAO,MAAM,UAAU,QAAO,IAO7B,CAAC"}

package/dist/lib/store/store.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetStore = exports.store = void 0;
+const microtime_1 = __importDefault(require("microtime"));
+const string_1 = require("@lib/utils/string");
+const logger_1 = require("@lib/utils/logger");
+const cache_1 = require("@lib/utils/cache");
+// Instantiate the subset cache so it can be accessed faster.
+const subsetCache = cache_1.cache.bin('store-subset');
+const initIndex = () => {
+    return {
+        url: new Map(),
+        uuid: new Map(),
+        custom: new Map(),
+    };
+};
+const initData = () => new Map();
+exports.store = {
+    syncDate: null,
+    data: initData(),
+    deleted: new Set(),
+    index: initIndex(),
+};
+exports.store.data.subset = (options) => {
+    const startDate = microtime_1.default.now();
+    // Merge provided options with default ones.
+    const defaultOptions = {
+        variant: '_main',
+        ext: 'json',
+        recursive: 'true',
+    };
+    const opts = { ...defaultOptions, ...options };
+    let subset = { filenames: [], items: [] };
+    const dirWithTrimmedSlashes = opts.dir?.replace(/^\//, '').replace(/\/$/, '');
+    const dirPart = dirWithTrimmedSlashes ? `${dirWithTrimmedSlashes}/` : '';
+    let variantPart;
+    if (opts.variant) {
+        const recursiveGroup = opts.recursive ? '.' : '[^/]';
+        variantPart =
+            opts.variant === '_main'
+                ? `((?!--)${recursiveGroup})+`
+                : `${recursiveGroup}+${string_1.VARIANT_SEPARATOR}${opts.variant}`;
+    }
+    else {
+        variantPart = '';
+    }
+    let extensionPart;
+    if (opts.recursive) {
+        extensionPart = opts.ext ? `.${opts.ext}` : '.+';
+    }
+    else {
+        extensionPart = opts.ext ? `.${opts.ext}` : '[^/]+';
+    }
+    const pattern = `^${dirPart}${variantPart}${extensionPart}$`;
+    logger_1.logger.debug(`Store subset pattern: ${pattern}`);
+    const cachedSubset = subsetCache.get(pattern);
+    if (cachedSubset) {
+        subset = cachedSubset;
+        logger_1.logger.debug(`Store subset obtained from cache in ${(microtime_1.default.now() - startDate) / 1000}ms. ${subset.items.length} items.`);
+    }
+    else {
+        const regex = new RegExp(pattern);
+        const mapKeys = Array.from(exports.store.data.keys());
+        mapKeys.forEach(k => {
+            if (k.match(regex)) {
+                subset.filenames.push(k);
+                subset.items.push(exports.store.data.get(k));
+            }
+        });
+        subsetCache.set(pattern, subset);
+        logger_1.logger.debug(`Store subset created in ${(microtime_1.default.now() - startDate) / 1000} ms. ${subset.items.length} items.`);
+    }
+    return subset;
+};
+/**
+ * Resets store and deletes all loaded data.
+ */
+const resetStore = () => {
+    exports.store.syncDate = null;
+    const previousSubset = exports.store.data.subset;
+    exports.store.data = initData();
+    exports.store.data.subset = previousSubset;
+    exports.store.deleted.clear();
+    exports.store.index = initIndex();
+};
+exports.resetStore = resetStore;

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

@@ -0,0 +1,231 @@
+export interface StoreData<K, V> extends Map<K, V> {
+    /**
+     * Create a subset with all files in store that match the given arguments.
+     *
+     * @remarks
+     * All subsets are automatically cached, so passing the same arguments
+     * will return the same subset from the cache.
+     *
+     * This is the preferred way of getting a subset of the store files,
+     * since is a simple function that most of the times only requires
+     * the first argument.
+     *
+     * @example
+     * ```
+     * // Get a subset of all nodes with "json" extension.
+     * dataServer.store.data.subset({ dir: 'en/entity/node/', variant: null });
+     *
+     * // Get a subset of all articles in all languages with "json" extension.
+     * dataServer.store.data.subset({ dir: '.+/entity/node/article/' });
+     *
+     * // Get a subset of all articles regardless of their extension.
+     * dataServer.store.data.subset({ dir: 'en/entity/node/article/', ext: null });
+     *
+     * // Get a subset of all card variants for articles with "json" extension.
+     * dataServer.store.data.subset({ dir: 'en/entity/node/article/', variant: null });
+     *
+     * // Get a subset of english articles, with "yml" extension, non-recursively.
+     * dataServer.store.data.subset({ dir: 'en/entity/node/article/', ext: 'yml', recursive: false });
+     * ```
+     *
+     * @param options - Object with options for creating a store subset.
+     *
+     * @returns An object with "filenames" and "items".
+     */
+    subset(options: StoreSubsetOptions): StoreSubset;
+}
+/**
+ * The store that holds all data.
+ */
+export declare type Store = {
+    /**
+     * Date to tell when was the store last synced.
+     *
+     * Every time the store is updated, syncDate is set with the last modification
+     * date of the data directory, not the date when the store has finished updating.
+     *
+     * Given this scenario:
+     * - Data directory modified at 12:30:00
+     * - Syncing the store takes 3 seconds and finishes at 12:30:03
+     *
+     * ... syncDate will be 12:30:00, not 12:30:03.
+     *
+     * Doing it the other way round can cause data inconsistencies, because syncing files
+     * to the store takes time, it is done sequentially, and in the meanwhile, other
+     * modifications can happen:
+     * - Store last syncDate is 12:29:00
+     * - Data directory is modified at 12:30:00
+     * - We ask for modified files after 12:29:00 and got 3 files (1.json, 2.json and 3.json)
+     * - File "1.json" is processed and added to the store at 12:30:01
+     * - While "2.json" is being processed and added to the store, data directory is modified
+     * again at 12:30:02 and "1.json" is changed.
+     * - File "3.json" is processed and added to the store at 12:30:03
+     *
+     * At this moment, there are two options:
+     *
+     * 1) Setting syncDate to the current date:
+     * - Store syncDate is set to 12:30:03
+     * - Data directory is modified again at 12:30:10 and only "3.json" is changed
+     * - We ask for modified files after 12:30:03 and get only "3.json"
+     * - Modification done at 12:30:02 to "1.json" is lost and cannot be recovered unless "1.json" is
+     * modified again, or Data Server is restarted
+     *
+     * 2) Setting syncDate to the last modification date of the data directory:
+     * - Store syncDate is set to 12:30:00
+     * - Data directory is modified again at 12:30:10 and only "3.json" is changed
+     * - We ask for modified files after 12:30:00 and get "1.json" and "3.json"
+     * - Modification done at 12:30:02 to "1.json" is properly processed
+     */
+    syncDate: Date | null;
+    /**
+     * Map that holds all data for all files.
+     *
+     * @remarks
+     * This map contains files, keyed by their relative filepath. No directory or
+     * any other structure is stored here.
+     *
+     * When executing a query, a common pattern is to create a subset of this
+     * map (e.g.- to get all articles of an specific language) and the execute the
+     * query against that subset. To do so, see {@link Store#subset}
+     *
+     * @example
+     * ```
+     * // Find an specific article.
+     * const article = store.data.get('en/entity/node/article/123.json');
+     * const article = store.index.url.get('public/pretty/url');
+     * const article = store.index.uuid.get('nl').get('ce736c8b-a6ea-43c4-9a6b-ad1fc498017c');
+     * const article = store.index.custom.get('taxonomies').get('12234');
+     *
+     * // Create a subset of all english articles.
+     * const results = store.data.subset({ dir: 'en/entity/node/article/', recursive: true });
+     * ```
+     */
+    data: StoreData<string, any>;
+    /**
+     * A list of deleted files from store, to be able to track them.
+     */
+    deleted: Set<string>;
+    /**
+     * An object to hold accessory index data.
+     */
+    index: {
+        /**
+         * An index that holds all data for all files, keyed by their URL.
+         */
+        url: Map<string, any>;
+        /**
+         * An index that holds all data for all files, keyed by their lang and uuid.
+         */
+        uuid: Map<string, any>;
+        /**
+         * An index to hold custom data defined in hooks or queries.
+         */
+        custom: Map<string, any>;
+    };
+};
+/**
+ * Options for subset() function.
+ */
+export declare type StoreSubsetOptions = {
+    /**
+     * Optional base directory to filter files.
+     *
+     * @remarks
+     * It requires a trailing slash, but not a leading slash, e.g.- "en/entity/node/article/"
+     */
+    dir?: string;
+    /**
+     * Optional name of a variant file.
+     *
+     * @remarks
+     * Use '_main' to obtain the default variant.
+     * Use any other string, e.g.- 'card', to obtain the card variant.
+     * Use null to avoid searching for any variant.
+     * Defaults to '_main'.
+     */
+    variant?: string;
+    /**
+     * Optional file extension, without dots. Defaults to 'json'.
+     */
+    ext?: string;
+    /**
+     * Optional flag to search for files recursively. True by default.
+     */
+    recursive?: boolean;
+};
+/**
+ * Object holding a subset of items from the store.
+ */
+export declare type StoreSubset = {
+    /**
+     * Array of filenames in this subset.
+     */
+    filenames: Array<string>;
+    /**
+     * Array of items in this subset.
+     */
+    items: Array<any>;
+};
+/**
+ * The manager that handles the store data.
+ */
+export declare type StoreManager = {
+    /**
+     * Adds a file to the store, into a Map structure keyed by its relative filepath.
+     *
+     * @remarks
+     * It invokes "process file" and "store add" hooks.
+     *
+     * @param relativeFilepath - Relative file path, inside dataDir, to the file to be added.
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    add(relativeFilepath: string): StoreManager;
+    /**
+     * Removes a file from the store.
+     *
+     * @remarks
+     * It removes the file from the map structure.
+     * It invokes the "store remove" hook.
+     *
+     * @param file - Relative path to the file to be removed.
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    remove(file: string): StoreManager;
+    /**
+     * Updates a file from the store.
+     *
+     * @remarks
+     * It removes the file from the map structure, and adds it again.
+     *
+     * @param file - Relative path, inside dataDir, to the file to be updated.
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    update(file: string): StoreManager;
+    /**
+     * Parses all static and dynamic includes (entity, config, locale, custom and query)
+     * from data stored in "store.data".
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    parseIncludes(): StoreManager;
+    /**
+     * Parses all static and dynamic includes (entity, config, locale, custom and query)
+     * from one file.
+     *
+     * @param relativeFilepath - Relative file path, inside dataDir, to the file to be parsed.
+     * @param fileContent - The contents of a file.
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    parseSingleFileIncludes(relativeFilepath: string, fileContent: any): StoreManager;
+    /**
+     * Resets store and deletes all loaded data.
+     *
+     * @returns The store manager, to allow chaining.
+     */
+    reset(): StoreManager;
+};
+//# sourceMappingURL=store.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.types.d.ts","sourceRoot":"","sources":["../../../src/lib/store/store.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS,CAAC,CAAC,EAAE,CAAC,CAAE,SAAQ,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC;IAChD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,MAAM,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAAC;CAClD;AAED;;GAEG;AACH,oBAAY,KAAK,GAAG;IAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IAEtB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAErB;;OAEG;IACH,KAAK,EAAE;QACL;;WAEG;QACH,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEtB;;WAEG;QACH,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAEvB;;WAEG;QACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KAC1B,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,oBAAY,kBAAkB,GAAG;IAC/B;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;;;;;;;OAQG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,oBAAY,WAAW,GAAG;IACxB;;OAEG;IACH,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAEzB;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,oBAAY,YAAY,GAAG;IACzB;;;;;;;;;OASG;IACH,GAAG,CAAC,gBAAgB,EAAE,MAAM,GAAG,YAAY,CAAC;IAE5C;;;;;;;;;;OAUG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;IAEnC;;;;;;;;;OASG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAAC;IAEnC;;;;;OAKG;IACH,aAAa,IAAI,YAAY,CAAC;IAE9B;;;;;;;;OAQG;IACH,uBAAuB,CACrB,gBAAgB,EAAE,MAAM,EACxB,WAAW,EAAE,GAAG,GACf,YAAY,CAAC;IAEhB;;;;OAIG;IACH,KAAK,IAAI,YAAY,CAAC;CACvB,CAAC"}

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

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

package/dist/lib/store/storeManager.d.ts

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

package/dist/lib/store/storeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storeManager.d.ts","sourceRoot":"","sources":["../../../src/lib/store/storeManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AA2F7C,eAAO,MAAM,YAAY,EAAE,YA4F1B,CAAC"}

package/dist/lib/store/storeManager.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storeManager = void 0;
+const config_1 = require("@lib/config");
+const fs_1 = require("@lib/utils/fs");
+const hook_1 = require("./hook");
+const _1 = require(".");
+const include_1 = require("./include");
+const dependencyFileHelper_1 = require("./dependency/dependencyFileHelper");
+const dependencyTagger_1 = require("./dependency/dependencyTagger");
+/**
+ * Sets a file into the store, regardless of being already added or not.
+ *
+ * @param relativeFilepath - Relative file path, inside dataDir, to the file to be added.
+ * @param options - Configuration options.
+ *
+ * @returns Object with two properties, "raw" and "json".
+ */
+const setFileIntoStore = (relativeFilepath) => {
+    const absoluteFilePath = `${config_1.config.dataDir}/${relativeFilepath}`;
+    let fileContent = (0, fs_1.getFileContent)(absoluteFilePath);
+    // Invoke "process file" hook.
+    fileContent = hook_1.hookManager.invokeOnProcessFile({
+        relativeFilepath,
+        fileContent,
+    });
+    const dataToStore = fileContent.json || fileContent.raw;
+    if (fileContent.json) {
+        // Check if the object already exists to make sure we don't break the reference
+        const previousData = _1.store.data.get(relativeFilepath);
+        if (dataToStore && typeof dataToStore === 'object') {
+            if (previousData) {
+                // Delete include dependencies.
+                dependencyFileHelper_1.dependencyIncludeHelper.deleteIncludeDependencies(relativeFilepath, dataToStore);
+                // Remove previous data from URL index.
+                const url = previousData.data?.content?.url?.path;
+                if (url) {
+                    _1.store.index.url.delete(url);
+                }
+                // Remove previous data from UUID index.
+                const uuid = previousData.data?.content?.uuid;
+                const langcode = previousData.data?.content?.langcode?.value;
+                if (uuid && langcode) {
+                    _1.store.index.uuid.get(langcode)?.delete(uuid);
+                }
+                // Delete all referenced object properties
+                Object.keys(previousData).forEach(key => {
+                    delete previousData[key];
+                });
+                // hydrate new object properties into referenced object
+                Object.keys(dataToStore).forEach(key => {
+                    previousData[key] = dataToStore[key];
+                });
+            }
+            // Add data to UUID index.
+            const uuid = dataToStore.data?.content?.uuid;
+            const langcode = dataToStore.data?.content?.langcode?.value;
+            if (uuid && langcode) {
+                const langcodeMap = _1.store.index.uuid.get(langcode) ||
+                    _1.store.index.uuid.set(langcode, new Map()).get(langcode);
+                langcodeMap.set(uuid, dataToStore);
+            }
+            // Add data to URL index.
+            const url = dataToStore.data?.content?.url?.path;
+            if (url) {
+                _1.store.index.url.set(url, dataToStore);
+            }
+            // Add include dependencies.
+            dependencyFileHelper_1.dependencyIncludeHelper.setIncludeDependencies(relativeFilepath, dataToStore);
+        }
+    }
+    _1.store.data.set(relativeFilepath, dataToStore);
+    // Remove this path from store.deleted
+    _1.store.deleted.delete(relativeFilepath);
+    return fileContent;
+};
+exports.storeManager = {
+    add: (relativeFilepath) => {
+        const fileContent = setFileIntoStore(relativeFilepath);
+        // Invoke "store add" hook.
+        hook_1.hookManager.invokeOnStoreItemAdd({ relativeFilepath, fileContent });
+        return exports.storeManager;
+    },
+    update: (relativeFilepath) => {
+        const storedData = _1.store.data.get(relativeFilepath);
+        if (storedData) {
+            hook_1.hookManager.invokeOnStoreItemBeforeUpdate({
+                relativeFilepath,
+                fileContent: storedData,
+            });
+        }
+        const fileContent = setFileIntoStore(relativeFilepath);
+        // Invalidate this item.
+        dependencyTagger_1.dependencyTagger.invalidateTags([relativeFilepath]);
+        // Invoke "store update" hook.
+        hook_1.hookManager.invokeOnStoreItemAfterUpdate({
+            relativeFilepath,
+            fileContent,
+        });
+        return exports.storeManager;
+    },
+    remove: (relativeFilepath) => {
+        // Get stored data before removing it from store.
+        const storedData = _1.store.data.get(relativeFilepath);
+        // Remove data from URL index.
+        const url = storedData.data?.content?.url?.path;
+        if (url) {
+            _1.store.index.url.delete(url);
+        }
+        // Remove data from UUID index.
+        const uuid = storedData.data?.content?.uuid;
+        const langcode = storedData.data?.content?.langcode?.value;
+        if (uuid && langcode) {
+            _1.store.index.uuid.get(langcode)?.delete(uuid);
+        }
+        // Delete file contents from store.
+        _1.store.data.delete(relativeFilepath);
+        // Save its path in store.deleted for future reference.
+        _1.store.deleted.add(relativeFilepath);
+        // Invalidate this item.
+        dependencyTagger_1.dependencyTagger.invalidateTags([relativeFilepath]);
+        // Invoke "store remove" hook.
+        hook_1.hookManager.invokeOnStoreItemDelete({
+            relativeFilepath,
+            fileContent: storedData,
+        });
+        return exports.storeManager;
+    },
+    parseIncludes: () => {
+        // Parses static includes.
+        _1.store.data.forEach((fileContent, relativeFilepath) => {
+            include_1.includeParser.static(relativeFilepath, fileContent);
+        });
+        // Parses dynamic includes.
+        _1.store.data.forEach(fileContent => {
+            include_1.includeParser.dynamic(fileContent);
+        });
+        return exports.storeManager;
+    },
+    parseSingleFileIncludes: (relativeFilepath, fileContent) => {
+        include_1.includeParser.static(relativeFilepath, fileContent);
+        include_1.includeParser.dynamic(fileContent);
+        return exports.storeManager;
+    },
+    reset: () => {
+        (0, _1.resetStore)();
+        return exports.storeManager;
+    },
+};

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

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

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

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

package/dist/lib/store/workDir/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("./workDirHelper"), exports);

package/dist/lib/store/workDir/storage/getChangedLinesSince.d.ts

@@ -0,0 +1,9 @@
+/**
+   * Get changed files since a date.
+   *
+   * @param sinceDate - Date to search
+
+  * @returns Array of changed lines
+   */
+export declare const getChangedLinesSince: (sinceDate: Date) => string[];
+//# sourceMappingURL=getChangedLinesSince.d.ts.map

package/dist/lib/store/workDir/storage/getChangedLinesSince.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getChangedLinesSince.d.ts","sourceRoot":"","sources":["../../../../../src/lib/store/workDir/storage/getChangedLinesSince.ts"],"names":[],"mappings":"AAIA;;;;;;KAMK;AACL,eAAO,MAAM,oBAAoB,cAAe,IAAI,KAAG,MAAM,EAmC5D,CAAC"}