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

package/dist/lib/store/dependency/dependencyManager copy.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyManager = void 0;
+const dependencyTree = new Map();
+const invalidatedTags = new Set();
+const invalidatedFilepaths = new Set();
+/**
+ * Gets a list of parents of a dependency tag
+ */
+const getTagParents = (tag, parents = new Set()) => {
+    dependencyTree.forEach((children, parent) => {
+        if (children.has(tag)) {
+            parents.add(parent);
+            getTagParents(parent, parents);
+        }
+    });
+    return parents;
+};
+/**
+ * Gets a recursive list of invalidated tags.
+ *
+ * @remarks
+ * Iterates over all explicitly invalidated tags, and obtains all
+ * its parents.
+ */
+const getInvalidatedTags = () => {
+    const tags = new Set();
+    invalidatedTags.forEach(invalidatedTag => {
+        // Mark this tag as invalidated.
+        tags.add(invalidatedTag);
+        // Search for parents of this invalidated tag.
+        getTagParents(invalidatedTag).forEach(parentTag => {
+            tags.add(parentTag);
+        });
+    });
+    return Array.from(tags);
+};
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+exports.dependencyManager = {
+    setDependency: (tag, dependsOnTags) => {
+        const previousData = dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags.forEach(dependsOnTag => previousData.add(dependsOnTag));
+        }
+        else {
+            dependencyTree.set(tag, new Set(dependsOnTags));
+        }
+    },
+    deleteDependency: (tag, dependsOnTags) => {
+        const previousData = dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags.forEach(dependsOnTag => previousData.delete(dependsOnTag));
+            if (previousData.size === 0) {
+                dependencyTree.delete(tag);
+            }
+        }
+    },
+    invalidateTags: tags => {
+        tags.forEach(tag => {
+            invalidatedTags.add(tag);
+        });
+    },
+    trackInvalidatedFilepaths: () => {
+        // const invalidFilepaths = new Set<string>();
+        return getInvalidatedTags();
+        /*     store.data.forEach((json: Json, relativeFilepath: string) => {
+          if (json.metadata?.includes?.dynamic) {
+            Object.values(json.metadata.includes.dynamic).forEach(
+              queryDefinition => {
+                const tagsByQuery = tagsByQueryIndex.get(queryDefinition);
+                if (tagsByQuery) {
+                  // eslint-disable-next-line no-restricted-syntax
+                  for (const invalidatedTag of invalidatedTags) {
+                    if (tagsByQuery.has(invalidatedTag)) {
+                      invalidFilepaths.add(relativeFilepath);
+                      break;
+                    }
+                  }
+                } else {
+                  invalidFilepaths.add(relativeFilepath);
+                }
+              },
+            );
+          }
+        }); */
+        // return Array.from(invalidFilepaths);
+    },
+    getInvalidatedFilepaths: () => Array.from(invalidatedFilepaths),
+};

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

@@ -0,0 +1,6 @@
+import { DependencyManager } from './dependency.types';
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+export declare const dependencyManager: DependencyManager;
+//# sourceMappingURL=dependencyManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAkDvD;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBA2B/B,CAAC"}

package/dist/lib/store/dependency/dependencyManager.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyManager = void 0;
+const store_1 = require("../store");
+const dependencyTagger_1 = require("./dependencyTagger");
+const invalidatedFilepaths = {
+    updated: new Set(),
+    deleted: new Set(),
+};
+/**
+ * Gets a list of parents of a dependency tag
+ */
+const getTagParents = (tag, parents = new Set()) => {
+    (0, dependencyTagger_1.getReversedDependencyTree)()
+        .get(tag)
+        ?.forEach(parent => {
+        if (!parents.has(parent)) {
+            parents.add(parent);
+            getTagParents(parent, parents);
+        }
+    });
+    return parents;
+};
+/**
+ * Gets a recursive list of invalidated tags.
+ *
+ * @remarks
+ * Iterates over all explicitly invalidated tags, and obtains all
+ * its parents.
+ */
+const getInvalidatedTags = () => {
+    const allInvalidatedTags = new Set();
+    const invalidatedTagsArray = Array.from(dependencyTagger_1.invalidatedTags);
+    if (invalidatedTagsArray.length > 0) {
+        invalidatedTagsArray.push('*');
+    }
+    invalidatedTagsArray.forEach(invalidatedTag => {
+        // Mark this tag as invalidated.
+        if (invalidatedTag !== '*') {
+            allInvalidatedTags.add(invalidatedTag);
+        }
+        // Search for parents of this invalidated tag.
+        getTagParents(invalidatedTag).forEach(parentTag => {
+            allInvalidatedTags.add(parentTag);
+        });
+    });
+    return Array.from(allInvalidatedTags);
+};
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+exports.dependencyManager = {
+    trackInvalidatedFilepaths: () => {
+        const allInvalidatedTags = getInvalidatedTags();
+        allInvalidatedTags.forEach(invalidatedTag => {
+            if (store_1.store.deleted.has(invalidatedTag)) {
+                invalidatedFilepaths.deleted.add(invalidatedTag);
+                invalidatedFilepaths.updated.delete(invalidatedTag);
+            }
+            else if (store_1.store.data.has(invalidatedTag)) {
+                invalidatedFilepaths.updated.add(invalidatedTag);
+                invalidatedFilepaths.deleted.delete(invalidatedTag);
+            }
+        });
+    },
+    getInvalidatedFilepaths: () => {
+        exports.dependencyManager.trackInvalidatedFilepaths();
+        return {
+            updated: Array.from(invalidatedFilepaths.updated),
+            deleted: Array.from(invalidatedFilepaths.deleted),
+        };
+    },
+    reset: () => {
+        dependencyTagger_1.invalidatedTags.clear();
+        invalidatedFilepaths.updated.clear();
+        invalidatedFilepaths.deleted.clear();
+    },
+};

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

@@ -0,0 +1,48 @@
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+export declare type DependencyManager = {
+    /**
+     * Sets a dependency relationship between a tag that depends on another tags.
+     *
+     * @param tag - A tag to set a dependency for.
+     * @param dependsOnTags - An array of tags that depends on first parameter tag.
+     */
+    setDependency(tag: string, dependsOnTags: string[]): void;
+    /**
+     * Deletes a dependency relationship between a tag that depends on another tags.
+     *
+     * @param tag - A tag to delete a dependency for.
+     * @param dependsOnTags - An array of tags that depends on first parameter tag.
+     */
+    deleteDependency(tag: string, dependsOnTags: string[]): void;
+    /**
+     * Marks dependency items with any of the specified tags as invalid.
+     *
+     * @param tags - The list of tags for which to invalidate dependency items.
+     */
+    invalidateTags(tags: string[]): void;
+    /**
+     * Resets the list of invalidated tags once consumed.
+     */
+    /**
+     * Calculates and tracks down a list of filepaths which contain an invalidated tag.
+     *
+     * @remarks
+     * It calculates which filepaths have been invalidated, and stores them so they
+     * can be consumed later. This function should be called before the store is updated,
+     * before any dependency data changes, to avoid losing the set of invalidated filepaths
+     * between updates.
+     */
+    trackInvalidatedFilepaths(): void;
+    /**
+     * Gets a list of filepaths which contain an invalidated tag.
+     *
+     * @remarks
+     * It uses the set of tracked down filepaths from
+     *
+     * @returns A list of filepaths which contain an invalidated tag.
+     */
+    getInvalidatedFilepaths(): string[];
+};
+//# sourceMappingURL=dependencyManager.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyManager.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyManager.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,iBAAiB,GAAG;IAC9B;;;;;OAKG;IACH,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE1D;;;;;OAKG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAE7D;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAErC;;OAEG;IAGH;;;;;;;;OAQG;IACH,yBAAyB,IAAI,IAAI,CAAC;IAElC;;;;;;;OAOG;IACH,uBAAuB,IAAI,MAAM,EAAE,CAAC;CACrC,CAAC"}

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

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

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

@@ -0,0 +1,6 @@
+import { DependencyManager } from './dependencyManager.types';
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+export declare const dependencyManager: DependencyManager;
+//# sourceMappingURL=dependencyTagManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyTagManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyTagManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AA2C9D;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAsD/B,CAAC"}

package/dist/lib/store/dependency/dependencyTagManager.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyTagManager = exports.invalidatedTags = exports.dependencyTree = void 0;
+exports.dependencyTree = new Map();
+exports.invalidatedTags = new Set();
+/**
+ * Manager that keeps control of dependencies between data.
+ */
+exports.dependencyTagManager = {
+    setDependency: (tag, dependsOnTags) => {
+        const previousData = exports.dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags.forEach(dependsOnTag => previousData.add(dependsOnTag));
+        }
+        else {
+            exports.dependencyTree.set(tag, new Set(dependsOnTags));
+        }
+    },
+    deleteDependency: (tag, dependsOnTags) => {
+        const previousData = exports.dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags.forEach(dependsOnTag => previousData.delete(dependsOnTag));
+            if (previousData.size === 0) {
+                exports.dependencyTree.delete(tag);
+            }
+        }
+    },
+    invalidateTags: tags => {
+        tags.forEach(tag => {
+            exports.invalidatedTags.add(tag);
+        });
+    },
+};

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

@@ -0,0 +1,11 @@
+import { DependencyTagger, DependencyTree } from './dependency.types';
+export declare const dependencyTree: DependencyTree;
+export declare const invalidatedTags: Set<string>;
+/**
+ * Makes a reverted version of the dependency tree
+ *
+ * @remarks Required to be able to search for dependencies in a fast way.
+ */
+export declare const getReversedDependencyTree: () => DependencyTree;
+export declare const dependencyTagger: DependencyTagger;
+//# sourceMappingURL=dependencyTagger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencyTagger.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/dependency/dependencyTagger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEtE,eAAO,MAAM,cAAc,EAAE,cAA+C,CAAC;AAE7E,eAAO,MAAM,eAAe,aAAoB,CAAC;AAMjD;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,sBAiBrC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,gBAgC9B,CAAC"}

package/dist/lib/store/dependency/dependencyTagger.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dependencyTagger = exports.getReversedDependencyTree = exports.invalidatedTags = exports.dependencyTree = void 0;
+exports.dependencyTree = new Map();
+exports.invalidatedTags = new Set();
+const reversedDependencyTree = new Map();
+let reversedDependencyTreeIsValid = false;
+/**
+ * Makes a reverted version of the dependency tree
+ *
+ * @remarks Required to be able to search for dependencies in a fast way.
+ */
+const getReversedDependencyTree = () => {
+    if (!reversedDependencyTreeIsValid) {
+        reversedDependencyTree.clear();
+        exports.dependencyTree.forEach((children, parent) => {
+            children.forEach(child => {
+                const previousData = reversedDependencyTree.get(child);
+                if (previousData) {
+                    previousData.add(parent);
+                }
+                else {
+                    reversedDependencyTree.set(child, new Set([parent]));
+                }
+            });
+        });
+        reversedDependencyTreeIsValid = true;
+    }
+    return reversedDependencyTree;
+};
+exports.getReversedDependencyTree = getReversedDependencyTree;
+exports.dependencyTagger = {
+    setDependency: (tag, dependsOnTags) => {
+        exports.dependencyTree.set(tag, new Set(dependsOnTags));
+        reversedDependencyTreeIsValid = false;
+    },
+    addDependency: (tag, dependsOnTags) => {
+        const previousData = exports.dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags.forEach(dependsOnTag => previousData.add(dependsOnTag));
+        }
+        else {
+            exports.dependencyTree.set(tag, new Set(dependsOnTags));
+        }
+        reversedDependencyTreeIsValid = false;
+    },
+    deleteDependency: (tag, dependsOnTags) => {
+        const previousData = exports.dependencyTree.get(tag);
+        if (previousData) {
+            dependsOnTags?.forEach(dependsOnTag => previousData.delete(dependsOnTag));
+            if (previousData.size === 0) {
+                exports.dependencyTree.delete(tag);
+            }
+        }
+        reversedDependencyTreeIsValid = false;
+    },
+    invalidateTags: tags => {
+        tags.forEach(tag => {
+            exports.invalidatedTags.add(tag);
+        });
+    },
+};
+/*
+import { DependencyTagger } from './dependency.types';
+
+export const dependencyTree = new Map<string, Set<string>>();
+
+export const invalidatedTags = new Set<string>();
+
+export const dependencyTagger: DependencyTagger = {
+  setDependency: (tag, dependsOnTags) => {
+    dependsOnTags.forEach(dependsOnTag => {
+      const previousData = dependencyTree.get(dependsOnTag);
+      if (previousData) {
+        previousData.add(tag);
+      } else {
+        dependencyTree.set(dependsOnTag, new Set<string>([tag]));
+      }
+    });
+  },
+
+  deleteDependency: (tag, dependsOnTags) => {
+    dependsOnTags.forEach(dependsOnTag => {
+      const previousData = dependencyTree.get(dependsOnTag);
+      if (previousData) {
+        previousData.delete(tag);
+        if (previousData.size === 0) {
+          dependencyTree.delete(dependsOnTag);
+        }
+      }
+    });
+  },
+
+  invalidateTags: tags => {
+    tags.forEach(tag => {
+      invalidatedTags.add(tag);
+    });
+  },
+}; */

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"diffManager.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/diff/diffManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAQ,MAAM,qBAAqB,CAAC;AAMxD,eAAO,MAAM,WAAW,EAAE,WAgHzB,CAAC"}

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

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffManager = void 0;
+const microtime_1 = __importDefault(require("microtime"));
+const logger_1 = require("@lib/utils/logger");
+const store_1 = require("../store");
+const dataDirManager_1 = require("../dataDir/dataDirManager");
+const dependencyManager_1 = require("../dependency/dependencyManager");
+let lastDiffDate = null;
+exports.diffManager = {
+    reset(date) {
+        lastDiffDate = date;
+        dependencyManager_1.dependencyManager.reset();
+    },
+    getDiff(options = { incremental: true }) {
+        const startDate = microtime_1.default.now();
+        // Before getting any diff data, update any pending changes from data dir.
+        dataDirManager_1.dataDirManager.update();
+        let updated = new Set();
+        let deleted = new Set();
+        if (options.incremental && lastDiffDate) {
+            logger_1.logger.debug(`Getting incremental diff using date "${lastDiffDate}"`);
+            const invalidatedFilepaths = dependencyManager_1.dependencyManager.getInvalidatedFilepaths();
+            updated = new Set(invalidatedFilepaths.updated);
+            deleted = new Set(invalidatedFilepaths.deleted);
+        }
+        else {
+            // If no sinceDate is passed, return all files
+            logger_1.logger.debug(`Getting full diff with no date`);
+            updated = new Set(store_1.store.data.keys());
+        }
+        const diff = {
+            since: lastDiffDate ? lastDiffDate.getTime() : new Date(0).getTime(),
+            updated,
+            deleted,
+        };
+        logger_1.logger.info(`Diff created in ${(microtime_1.default.now() - startDate) / 1000} ms. Updated: ${diff.updated.size} / Deleted: ${diff.deleted.size}`);
+        // Log diff if not empty
+        // if (diff.updated.length || diff.deleted.length) {
+        // logger.debug(`Diff: "${JSON.stringify(jsonify(diff))}"`);
+        // }
+        return diff;
+    },
+    /*
+    getDiff(options = { incremental: true }): Diff {
+      const startDate = microtime.now();
+  
+      // Before getting any diff data, update any pending changes from data dir.
+      const changedFiles = dataDirManager.update();
+  
+      let updated = new Set<string>();
+      let deleted = new Set<string>();
+      const sinceDate = getLastDiffDate();
+      if (options.incremental && sinceDate) {
+        logger.debug(`Getting incremental diff using date "${sinceDate}"`);
+        // Only process changedFiles if not empty.
+        if (changedFiles.updated.length || changedFiles.deleted.length) {
+          // Update tracked files so no affected parent is missed.
+          changedFiles.updated.forEach(file => {
+            tracker.trackChangedFile(file);
+          });
+          changedFiles.deleted.forEach(file => {
+            tracker.trackChangedFile(file);
+          });
+        }
+  
+        // Create the resulting set of updated and deleted files.
+        // "updated" includes all affected parents tracked down
+        // by tracker, without any deleted file.
+        updated = new Set<string>(tracker.getChangedFiles());
+        changedFiles.deleted.forEach(file => updated.delete(file));
+  
+        // "deleted" includes only deleted files, and is based only
+        // on data coming from changedFiles, because all deleted files
+        // are stored on Static Suite Data Server log
+        deleted = new Set<string>(changedFiles.deleted);
+  
+        // Add updated files affected by queries only if "updated" or "deleted"
+        // contain any changes.
+        if (updated.size > 0 || deleted.size > 0) {
+          queryTagManager
+            .getInvalidFilepaths()
+            .forEach(file => updated.add(file));
+          queryTagManager.resetInvalidatedTags();
+        }
+      } else {
+        // If no sinceDate is passed, return all files
+        logger.debug(`Getting full diff with no date`);
+        updated = new Set<string>(store.data.keys());
+      }
+  
+      const diff: Diff = {
+        since: sinceDate ? sinceDate.getTime() : new Date(0).getTime(),
+        updated,
+        deleted,
+      };
+  
+      logger.info(
+        `Diff created in ${(microtime.now() - startDate) / 1000} ms. Updated: ${
+          diff.updated.size
+        } / Deleted: ${diff.deleted.size}`,
+      );
+  
+      // Log diff if not empty
+      // if (diff.updated.length || diff.deleted.length) {
+      // logger.debug(`Diff: "${JSON.stringify(jsonify(diff))}"`);
+      // }
+  
+      return diff;
+    }, */
+};

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

@@ -0,0 +1,50 @@
+/**
+ * Service that handles the incremental differences in data (includes and queries).
+ */
+export declare type DiffManager = {
+    /**
+     * Clears intermediate changes tracked by trackChangedFile().
+     *
+     * @param date - Date to be used as a timestamp for the next diff.
+     */
+    reset(date: Date): void;
+    /**
+     * Gets a list of changed files affected by includes and queries.
+     *
+     * @remarks
+     * This function does not need any date passed as argument to get a diff from.
+     * It simply uses the timestamp of the last generated diff. Calling this function does
+     * not automatically update that timestamp, because diff data must be stored in
+     * disk (a process called "dump"). Once a dump is finished, we can use the new
+     * timestamp for further diffs.
+     *
+     * To obtain a diff, we need changed files from:
+     *
+     * 1) includes: every time a file changes, all its parents are affected.
+     * 2) queries: there is no easy way to know if a changed file will alter a query,
+     *   so we run all of them and check if something has changed.
+  
+     * @param options - Configuration options
+     */
+    getDiff(options?: {
+        incremental: boolean;
+    }): Diff;
+};
+/**
+ * A group of changed files in Static Suite's data dir.
+ */
+export declare type Diff = {
+    /**
+     * Timestamp in milliseconds.
+     */
+    since: number;
+    /**
+     * A list of updated files (both newly added and changed files).
+     */
+    updated: Set<string>;
+    /**
+     * A list of deleted files.
+     */
+    deleted: Set<string>;
+};
+//# sourceMappingURL=diffManager.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"diffManager.types.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/diff/diffManager.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,WAAW,GAAG;IACxB;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;IAExB;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CACnD,CAAC;AAEF;;GAEG;AACH,oBAAY,IAAI,GAAG;IACjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAErB;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACtB,CAAC"}

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracker.d.ts","sourceRoot":"","sources":["../../../../src/lib/store/diff/tracker.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AA0B1C,eAAO,MAAM,OAAO,EAAE,OA0DrB,CAAC"}