feat(history): can get all the selective keys (linear history)

Author: arnobl

src/api/command/Selective.ts

@@ -49,11 +49,11 @@ export function Selective(target: unknown, propertyName: string): void {
 
 /**
  * Gets the selective entries (key/value) of the given object.
- * @param obj - The object to analyze.
+ * @param obj - The object to analyze that may contain selective properties.
  * @returns `undefined` if the object is not selective. A set of entries (key/value) corresponding
  * to the selective keys and their values of the given object.
  */
-function getSelectiveValue<T extends object>(obj: T): Partial<T> | undefined {
+export function getSelectiveValue<T extends object>(obj: T): Partial<T> | undefined {
     const keys: unknown = (obj.constructor as SelectiveMetadata)[INTERACTO_SELECTIVE];
 
     if (keys instanceof Set) {

src/api/history/LinearHistory.ts

@@ -118,4 +118,11 @@ export abstract class LinearHistory implements LinearHistoryBase {
      * If not valid, the method does nothing.
      */
     public abstract redoUpTo(index: number): void;
+
+    /**
+     * Gets all the unique selective objects of this history.
+     * @returns All the unique selective objects that used in the stored undoable objects.
+     * This concerns both the undo and redo stacks.
+     */
+    public abstract getAllSelectiveObjects(): ReadonlySet<unknown>;
 }

src/impl/history/LinearHistoryImpl.ts

@@ -16,7 +16,7 @@ import {LinearHistory} from "../../api/history/LinearHistory";
 import {Subject} from "rxjs";
 import type {Undoable} from "../../api/history/Undoable";
 import type {Observable} from "rxjs";
-import {hasSelectiveValue} from "../../api/command/Selective";
+import {getSelectiveValue, hasSelectiveValue} from "../../api/command/Selective";
 
 /**
  * Implementation of the linear history
@@ -233,4 +233,15 @@ export class LinearHistoryImpl extends LinearHistory {
             this.redo();
         }
     }
+
+    public getAllSelectiveObjects(): ReadonlySet<unknown> {
+        // Considering both the undo and redo stacks
+        // Using a set to remove duplicated values
+        return new Set([...this.undos, ...this.redos]
+            // Collecting the selective properties
+            .map((undoable: Undoable) => getSelectiveValue(undoable))
+            .filter(data => data !== undefined)
+            // Collecting only the value of the selective properties
+            .flatMap(data => Object.values(data)));
+    }
 }

test/command/selective.test.ts

@@ -218,6 +218,36 @@ describe("using a selective command", () => {
             expect(res[0]).toStrictEqual([cmd2]);
             expect(res[1]).toHaveLength(0);
         });
+
+        test("getAllSelectiveObjects works with shared keys", () => {
+            history.add(cmd2);
+            history.add(cmd1);
+            const res = [...history.getAllSelectiveObjects()];
+            expect(res).toHaveLength(1);
+            expect(res).toContain(cmd1.key);
+            // expect(res).toContain(cmd2.otherKey);
+        });
+
+        test("getAllSelectiveObjects works with several keys", () => {
+            cmd2 = new CmdSelective2("foo");
+            history.add(cmd2);
+            history.add(cmd1);
+            const res = [...history.getAllSelectiveObjects()];
+            expect(res).toHaveLength(2);
+            expect(res).toContain(cmd1.key);
+            expect(res).toContain(cmd2.otherKey);
+        });
+
+        test("getAllSelectiveObjects works by considering the redo stack", () => {
+            cmd2 = new CmdSelective2("foo");
+            history.add(cmd2);
+            history.add(cmd1);
+            history.undo();
+            const res = [...history.getAllSelectiveObjects()];
+            expect(res).toHaveLength(2);
+            expect(res).toContain(cmd1.key);
+            expect(res).toContain(cmd2.otherKey);
+        });
     });
 
     describe("and a linear history and specific key comparison function", () => {