@plohoj/html-editor 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,11 +1,11 @@
-import { throttleTime, mergeMap, distinctUntilChanged, switchMap, filter, map, take, shareReplay, tap, connect, takeUntil } from 'rxjs/operators';
-import { Observable, concat, defer, EMPTY, of, pipe, merge, from } from 'rxjs';
+import { throttleTime, mergeMap, distinctUntilChanged, switchMap, debounceTime, filter, map, take, tap, shareReplay, connect, takeUntil } from 'rxjs/operators';
+import { Observable, concat, defer, EMPTY, of, merge, fromEvent, pipe, from, tap as tap$1, share, NEVER, takeUntil as takeUntil$1, ignoreElements, ReplaySubject } from 'rxjs';
 
-function randomFromArray(array, from = 0, to = array.length) {
-    if (to < 0) {
-        to = array.length + to;
-    }
-    return array[Math.floor(Math.random() * (to - from)) + from];
+function trueStub() {
+    return true;
+}
+function falseStub() {
+    return false;
 }
 
 /**
@@ -23,7 +23,7 @@ function observeElementMutation(node, options) {
  * Returns change (addition and deletion) of element that match selectors, like an Rx stream.
  */
 function observeQuerySelector(query, options = {}) {
-    const { parent = document.documentElement, asRemovedWhen } = options;
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, } = options;
     let targetElement;
     function checkChanges() {
         const querySelectedElements = parent.querySelectorAll(query);
@@ -33,7 +33,7 @@ function observeQuerySelector(query, options = {}) {
             if (options.has && !querySelectedElement.querySelector(options.has)) {
                 continue;
             }
-            if (options.filter && !options.filter(querySelectedElement)) {
+            if (!filter(querySelectedElement)) {
                 continue;
             }
             filteredSelectedElement = querySelectedElement;
@@ -70,9 +70,25 @@ function observeQuerySelector(query, options = {}) {
     return observeQuerySelector$;
 }
 
+/**
+ * Awaiting only one element to match the selector and returns it as an Rx stream.
+ * The stream ends after one element is found / added.
+ */
+function awaitElement(query, options = {}) {
+    return observeQuerySelector(query, options)
+        .pipe(debounceTime(options.debounceTime || 0, options.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
+}
+
+function randomFromArray(array, from = 0, to = array.length) {
+    if (to < 0) {
+        to = array.length + to;
+    }
+    return array[Math.floor(Math.random() * (to - from)) + from];
+}
+
 /** Returns changes (additions and deletions) of elements that match selectors, like an Rx stream. */
 function observeQuerySelectorAll(query, options = {}) {
-    const { parent = document.documentElement, asRemovedWhen } = options;
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, } = options;
     const targetElements = new Set();
     function checkChanges() {
         const addedElements = new Set();
@@ -82,7 +98,7 @@ function observeQuerySelectorAll(query, options = {}) {
             if (options.has && !querySelectedElement.querySelector(options.has)) {
                 continue;
             }
-            if (options.filter && !options.filter(querySelectedElement)) {
+            if (!filter(querySelectedElement)) {
                 continue;
             }
             if (targetElementsDiff.has(querySelectedElement)) {
@@ -129,22 +145,23 @@ function observeQuerySelectorAll(query, options = {}) {
     return observeQuerySelectorAll$;
 }
 
-/**
- * Awaiting only one element to match the selector and returns it as an Rx stream.
- * The stream ends immediately after one element is found / added.
- */
-function awaitElement(query) {
-    return observeQuerySelector(query)
-        .pipe(filter(changes => !!changes.target), map(changes => changes.target), take(1));
-}
 /**
  * Awaiting Expects at least one element to match the selector and returns it as an Rx stream.
- * If there are more than 1 elements,
- * it will return a random one. The stream ends immediately after the elements are found / added.
+ * If there are more than 1 elements, it will return a random one.
+ * The stream ends after the elements are found / added.
  */
-function awaitRandomElement(query) {
-    return observeQuerySelectorAll(query)
-        .pipe(filter(changes => !!changes.target), map(changes => randomFromArray(changes.target)), take(1));
+function awaitRandomElement(query, options = {}) {
+    return observeQuerySelectorAll(query, options)
+        .pipe(debounceTime(options.debounceTime || 0, options.debounceScheduler), filter(changes => changes.target.length > 0), map(changes => randomFromArray(changes.target)), take(1));
+}
+
+function observePressedKeyboardButtons(options = {}) {
+    const target = options.target || window;
+    const set = new Set();
+    const addKey$ = merge(fromEvent(target, 'keydown'), fromEvent(target, 'keypress')).pipe(filter((event) => !set.has(event.key)), tap((event) => set.add(event.key)));
+    const keyRemove$ = fromEvent(target, 'keyup')
+        .pipe(filter((event) => set.has(event.key)), tap((event) => set.delete(event.key)));
+    return merge(addKey$, keyRemove$).pipe(map(() => set));
 }
 
 let pushStateSubscriber$;
@@ -196,24 +213,28 @@ function assuredArray(values) {
     }
     return [];
 }
-/** Conversion operator to a new stream for each new added element */
-function mergeMapAddedElements(project, options) {
-    if (!(options === null || options === void 0 ? void 0 : options.isTakeUntilRemoved)) {
+function mergeMapAddedElements(projectOrOptions, options) {
+    const project = typeof projectOrOptions === 'function'
+        ? projectOrOptions
+        : (element) => of(element);
+    options = typeof projectOrOptions === 'object' ? projectOrOptions : options;
+    const { isTakeUntilRemoved = false } = options || {};
+    if (!isTakeUntilRemoved) {
         return source$ => source$.pipe(mergeMap(changes => {
-            let added = assuredArray(changes.added);
+            const added = assuredArray(changes.added);
             if (added.length === 0) {
                 return EMPTY;
             }
-            let addedObservers = added.map(project);
+            const addedObservers = added.map(project);
             return merge(...addedObservers);
         }));
     }
     return source$ => source$.pipe(connect(connectedSource$ => connectedSource$.pipe(mergeMap(changes => {
-        let added = assuredArray(changes.added);
+        const added = assuredArray(changes.added);
         if (added.length === 0) {
             return EMPTY;
         }
-        let addedObservers = added.map(addedElement => from(project(addedElement)).pipe(takeUntil(connectedSource$.pipe(filter(changes => {
+        const addedObservers = added.map(addedElement => from(project(addedElement)).pipe(takeUntil(connectedSource$.pipe(filter(changes => {
             if (changes.removed instanceof Array) {
                 return changes.removed.indexOf(addedElement) != -1;
             }
@@ -225,6 +246,22 @@ function mergeMapAddedElements(project, options) {
     }))));
 }
 
+/** The operator creates a separate stream when the source string is validated. */
+function mergeMapStringToggle(condition, project, options) {
+    const mapConditionFn = typeof condition === 'function' ? condition : (url) => condition.test(url);
+    let urlMatchToggler;
+    if (typeof project === 'function') {
+        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project()) : EMPTY;
+    }
+    else {
+        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project) : EMPTY;
+    }
+    const mergeOperator = (options === null || options === void 0 ? void 0 : options.isTakeUntilToggle)
+        ? switchMap(urlMatchToggler)
+        : mergeMap(urlMatchToggler);
+    return pipe(map(mapConditionFn), distinctUntilChanged(), mergeOperator);
+}
+
 function removeElement() {
     return pipe(tap((element) => {
         element.remove();
@@ -232,6 +269,36 @@ function removeElement() {
     }));
 }
 
+function restoreHistory(options) {
+    return (source$) => {
+        let hasStory = false;
+        const observeCancel$ = options.cancelRestore
+            ? defer(() => options.cancelRestore())
+                .pipe(tap$1(() => {
+                if (hasStory) {
+                    options.removeStory();
+                }
+            }), share())
+            : NEVER;
+        const story$ = concat(defer(() => {
+            const story = options.getStory();
+            if (story === undefined) {
+                return EMPTY;
+            }
+            hasStory = true;
+            let rested$ = of(story);
+            if (options.cancelRestore) {
+                rested$ = rested$.pipe(takeUntil$1(observeCancel$));
+            }
+            return rested$;
+        }), source$.pipe(tap$1((data) => {
+            options.setStory(data);
+            hasStory = true;
+        })));
+        return merge(story$, observeCancel$.pipe(ignoreElements()));
+    };
+}
+
 function setInputValueImmediately(element, value) {
     element.value = value;
     element.focus();
@@ -247,58 +314,150 @@ function setInputValue(elementOrValue, value) {
     }
 }
 
-/** The operator creates a separate stream when the source string is validated. */
-function mergeMapStringToggle(condition, project, options) {
-    const mapConditionFn = typeof condition === 'function' ? condition : (url) => condition.test(url);
-    let urlMatchToggler;
-    if (typeof project === 'function') {
-        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project()) : EMPTY;
+function composeRestoreHistory(options) {
+    const cancelSubject$ = new ReplaySubject(1);
+    function cancelAll() {
+        cancelSubject$.next();
+    }
+    function convertOption(option) {
+        return restoreHistory(Object.assign(Object.assign({}, option), { cancelRestore: !!option.cancelRestore
+                ? () => merge(cancelSubject$, option.cancelRestore())
+                : () => cancelSubject$ }));
+    }
+    let operators;
+    if (options instanceof Array) {
+        operators = options.map(convertOption);
     }
     else {
-        urlMatchToggler = (isUrlMatch) => isUrlMatch ? from(project) : EMPTY;
+        operators = {};
+        for (const key of Object.keys(options)) {
+            operators[key] = convertOption(options[key]);
+        }
     }
-    const mergeOperator = (options === null || options === void 0 ? void 0 : options.isTakeUntilToggle)
-        ? switchMap(urlMatchToggler)
-        : mergeMap(urlMatchToggler);
-    return pipe(map(mapConditionFn), distinctUntilChanged(), mergeOperator);
+    return {
+        operators: operators,
+        cancelAll,
+    };
 }
 
-function findRecursively(obj, mather) {
-    const seen = new Set();
+/** Recursive search on entity fields */
+function findRecursively(obj, options = {}) {
+    var _a;
+    /** {value: path[]} */
+    const seen = new Map();
     const searched = {};
-    const needFind = new Set([[undefined, obj]]);
-    function addToCheck(path, value) {
-        if (seen.has(value)) {
+    const needSeen = new Set([{
+            value: obj,
+            depth: 0,
+        }]);
+    const { matcher = falseStub, filter = trueStub, continueAfterGetterError = trueStub, stop = falseStub, minDepth = 1, maxDepth = Infinity, } = options;
+    const pathRegExpCheck = options.pathRegExp
+        ? (path) => { var _a; return path ? (_a = options.pathRegExp) === null || _a === void 0 ? void 0 : _a.test(path) : false; }
+        : falseStub;
+    const fieldRegExpCheck = options.fieldRegExp
+        ? (field) => { var _a; return typeof field === 'string' ? (_a = options.fieldRegExp) === null || _a === void 0 ? void 0 : _a.test(field) : false; }
+        : falseStub;
+    let needStop = false;
+    function checkForNeedSeen(options) {
+        if (options.depth > maxDepth) {
+            return;
+        }
+        const isPrimitiveOrFunction = options.value === null || typeof options.value !== 'object';
+        if (!isPrimitiveOrFunction) {
+            const seenPathsForValue = seen.get(options.value);
+            if (seenPathsForValue) {
+                // TODO windows or document
+                // TODO List of visited objects, but with the wrong path
+                const hasCircularPath = seenPathsForValue.some(path => options.path && (path === null || path === void 0 ? void 0 : path.includes(options.path)));
+                if (hasCircularPath) {
+                    return;
+                }
+            }
+            if (filter(options)) {
+                needSeen.add(options);
+                if (seenPathsForValue) {
+                    seenPathsForValue.push(options.path);
+                }
+                else {
+                    seen.set(options.value, [options.path]);
+                }
+            }
+        }
+        if (options.depth < minDepth) {
             return;
         }
-        needFind.add([path, value]);
-        seen.add(value);
+        if (matcher(options) || pathRegExpCheck(options.path) || fieldRegExpCheck(options.field)) {
+            searched[options.path || '{}'] = options.value;
+            if (stop(searched)) {
+                needStop = true;
+            }
+        }
     }
-    while (true) {
-        const iterator = needFind.values().next();
+    function iterateArrayLike(iterator, pathBuilder, incrementalDepth) {
+        for (const [fieldIndex, fieldValue] of iterator) {
+            checkForNeedSeen({
+                field: fieldIndex,
+                value: fieldValue,
+                path: pathBuilder(fieldIndex),
+                depth: incrementalDepth,
+            });
+            if (needStop) {
+                return;
+            }
+        }
+    }
+    while (!needStop) {
+        const iterator = needSeen.values().next();
         if (iterator.done) {
             break;
         }
-        const path = iterator.value[0];
-        const iteratedObj = iterator.value[1];
-        needFind.delete(iterator.value);
-        if (!iteratedObj) {
-            continue;
+        const { value, path, depth } = iterator.value;
+        const incrementalDepth = depth + 1;
+        needSeen.delete(iterator.value);
+        if (value instanceof Array) {
+            iterateArrayLike(value.entries(), (fieldIndex) => `${path || ''}[${fieldIndex}]`, incrementalDepth);
+        }
+        if (value instanceof Map) {
+            iterateArrayLike(value.entries(), (fieldIndex) => `${path || ''}{${fieldIndex}}`, incrementalDepth);
         }
-        if (iteratedObj instanceof Array) {
-            for (const [index, value] of iteratedObj.entries()) {
-                if (value)
-                    addToCheck(`${path || ''}[${index}]`, value);
+        if (value instanceof Set) {
+            for (const [fieldIndex, fieldValue] of [...value].entries()) {
+                checkForNeedSeen({
+                    field: fieldValue,
+                    value: fieldValue,
+                    path: `${path || ''}<${fieldIndex}>`,
+                    depth: incrementalDepth,
+                });
+                if (needStop) {
+                    break;
+                }
             }
         }
-        else if (typeof iteratedObj === "object") {
-            for (const key of Object.keys(iteratedObj)) {
-                const value = iteratedObj[key];
-                const keyPath = path ? `${path}.${key}` : key;
-                if (mather(key, value, keyPath)) {
-                    searched[keyPath] = value;
+        else if (typeof value === "object") {
+            for (const key of Object.keys(value)) {
+                let fieldValue;
+                if (((_a = Object.getOwnPropertyDescriptor(value, key)) === null || _a === void 0 ? void 0 : _a.get) && options.isIgnoreGetters) {
+                    continue;
+                }
+                try {
+                    fieldValue = value[key];
+                }
+                catch (error) {
+                    if (!continueAfterGetterError(error)) {
+                        needStop = true;
+                        break;
+                    }
+                    fieldValue = error;
+                }
+                checkForNeedSeen({
+                    field: key,
+                    value: fieldValue,
+                    path: path ? `${path}.${key}` : key,
+                    depth: incrementalDepth
+                });
+                if (needStop) {
+                    break;
                 }
-                addToCheck(keyPath, value);
             }
         }
     }
@@ -306,10 +465,7 @@ function findRecursively(obj, mather) {
         return null;
     }
     return searched;
-}
-function findRecursivelyPropertyName(obj, propertyName) {
-    return findRecursively(obj, matchedPropertyName => matchedPropertyName === propertyName);
 }
 
-export { awaitElement, awaitRandomElement, clickElement, findRecursively, findRecursivelyPropertyName, mergeMapAddedElements, mergeMapStringToggle, observeElementMutation, observeQuerySelector, observeQuerySelectorAll, randomFromArray, removeElement, setInputValue, urlChange$ };
+export { awaitElement, awaitRandomElement, clickElement, composeRestoreHistory, findRecursively, mergeMapAddedElements, mergeMapStringToggle, observeElementMutation, observePressedKeyboardButtons, observeQuerySelector, observeQuerySelectorAll, randomFromArray, removeElement, restoreHistory, setInputValue, urlChange$ };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plohoj/html-editor",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "html-editor it's a tool for helping modification html elements",
   "repository": {
     "type": "git",

package/src/index.ts

@@ -1,15 +1,19 @@
 // Observable
-export { awaitElement, awaitRandomElement } from "./observable/await-element";
+export { awaitElement, IAwaitElementOptions } from "./observable/await-element";
+export { awaitRandomElement } from './observable/await-random-element';
 export { observeElementMutation } from "./observable/observe-mutation";
-export { observeQuerySelector } from "./observable/observe-query-selector";
-export { observeQuerySelectorAll } from "./observable/observe-query-selector-all";
+export { IObservePressedKeyboardButtonsOptions, observePressedKeyboardButtons } from './observable/observe-pressed-keyboard-buttons';
+export { IObserveElementChange, IObserveQuerySelectorBaseOptions, IObserveQuerySelectorOptions, observeQuerySelector } from "./observable/observe-query-selector";
+export { IObservedElementsChanges, observeQuerySelectorAll } from "./observable/observe-query-selector-all";
 export { urlChange$ } from "./observable/url-change";
 // Operators
 export { clickElement } from "./operators/click-element";
 export { mergeMapAddedElements } from "./operators/merge-map-added-elements";
+export { mergeMapStringToggle } from "./operators/merge-map-string-toggle";
 export { removeElement } from "./operators/remove-element";
+export { IRestoredHistoryOption, restoreHistory } from './operators/restore-history';
 export { setInputValue } from "./operators/set-input-value";
-export { mergeMapStringToggle } from "./operators/merge-map-string-toggle";
 // Utils
-export { findRecursively, findRecursivelyPropertyName, RecursivelyFindMather } from "./utils/find-recursively";
+export { ComposedRestoredHistoryOperatorsArray, ComposedRestoredHistoryOperatorsList, ComposedRestoredHistoryOperatorsRecord, ComposedRestoredHistoryOptionList, composeRestoreHistory, IComposedRestoredHistory } from './utils/compose-restore-history';
+export { findRecursively, FindRecursivelyContinue, FindRecursivelyMatcher, FindRecursivelyResult, IFindRecursivelyMatherOptions, IFindRecursivelyOptions } from "./utils/find-recursively";
 export { randomFromArray } from "./utils/random-from-array";

package/src/observable/await-element.ts

@@ -1,32 +1,30 @@
-import { Observable } from "rxjs";
-import { filter, map, take } from "rxjs/operators";
-import { randomFromArray } from "../utils/random-from-array";
-import { observeQuerySelector } from "./observe-query-selector";
-import { observeQuerySelectorAll } from "./observe-query-selector-all";
+import { Observable, SchedulerLike } from "rxjs";
+import { debounceTime, filter, map, take } from "rxjs/operators";
+import { IObserveQuerySelectorBaseOptions, observeQuerySelector } from "./observe-query-selector";
 
-/**
- * Awaiting only one element to match the selector and returns it as an Rx stream.
- * The stream ends immediately after one element is found / added.
- */
-export function awaitElement<T extends Element = Element>(query: string): Observable<T> {
-    return observeQuerySelector<T>(query)
-        .pipe(
-            filter(changes => !!changes.target),
-            map(changes => changes.target!),
-            take(1),
-        );
+export interface IAwaitElementOptions<T extends Element = Element> extends IObserveQuerySelectorBaseOptions<T> {
+    /**
+     * The time to wait for elements changes.
+     * If during the waiting time the elements have changed the timer will be reset.
+     * @default 0
+     */
+    debounceTime?: number;
+    debounceScheduler?: SchedulerLike;
 }
 
 /**
- * Awaiting Expects at least one element to match the selector and returns it as an Rx stream.
- * If there are more than 1 elements,
- * it will return a random one. The stream ends immediately after the elements are found / added.
+ * Awaiting only one element to match the selector and returns it as an Rx stream.
+ * The stream ends after one element is found / added.
  */
-export function awaitRandomElement<T extends Element = Element>(query: string): Observable<T> {
-    return observeQuerySelectorAll<T>(query)
+export function awaitElement<T extends Element = Element>(
+    query: string,
+    options: IAwaitElementOptions<T> = {},
+): Observable<T> {
+    return observeQuerySelector<T>(query, options)
         .pipe(
+            debounceTime(options.debounceTime || 0, options.debounceScheduler),
             filter(changes => !!changes.target),
-            map(changes => randomFromArray(changes.target)),
+            map(changes => changes.target!),
             take(1),
         );
 }

package/src/observable/await-random-element.ts

@@ -0,0 +1,23 @@
+import { Observable } from "rxjs";
+import { debounceTime, filter, map, take } from "rxjs/operators";
+import { randomFromArray } from "../utils/random-from-array";
+import { IAwaitElementOptions } from './await-element';
+import { observeQuerySelectorAll } from "./observe-query-selector-all";
+
+/**
+ * Awaiting Expects at least one element to match the selector and returns it as an Rx stream.
+ * If there are more than 1 elements, it will return a random one.
+ * The stream ends after the elements are found / added.
+ */
+export function awaitRandomElement<T extends Element = Element>(
+    query: string,
+    options: IAwaitElementOptions<T> = {},
+): Observable<T> {
+    return observeQuerySelectorAll<T>(query, options)
+        .pipe(
+            debounceTime(options.debounceTime || 0, options.debounceScheduler),
+            filter(changes => changes.target.length > 0),
+            map(changes => randomFromArray(changes.target)),
+            take(1)
+        );
+}

package/src/observable/observe-pressed-keyboard-buttons.ts

@@ -0,0 +1,31 @@
+import { fromEvent, merge, Observable } from 'rxjs';
+import { filter, map, tap } from 'rxjs/operators';
+import { HasEventTargetAddRemove } from 'rxjs/internal/observable/fromEvent';
+
+export interface IObservePressedKeyboardButtonsOptions {
+    /** @default window */
+    target?: HasEventTargetAddRemove<KeyboardEvent>
+}
+
+export function observePressedKeyboardButtons(
+    options: IObservePressedKeyboardButtonsOptions = {}
+): Observable<Set<string>> {
+    const target = options.target || window;
+    const set = new Set<string>();
+    const addKey$ = merge(
+        fromEvent(target, 'keydown'),
+        fromEvent(target, 'keypress'),
+    ).pipe(
+        filter((event: KeyboardEvent) => !set.has(event.key)),
+        tap((event: KeyboardEvent) => set.add(event.key)),
+    )
+    const keyRemove$ = fromEvent(target, 'keyup')
+        .pipe(
+            filter((event: KeyboardEvent) => set.has(event.key)),
+            tap((event: KeyboardEvent) => set.delete(event.key)),
+        );
+    return merge(
+        addKey$,
+        keyRemove$,
+    ).pipe(map(() => set));
+}

package/src/observable/observe-query-selector-all.ts

@@ -1,6 +1,7 @@
 
 import { concat, defer, EMPTY, Observable, of } from "rxjs";
 import { distinctUntilChanged, mergeMap, switchMap, throttleTime } from "rxjs/operators";
+import { trueStub } from '../utils/stubs';
 import { observeElementMutation } from "./observe-mutation";
 import { IObserveQuerySelectorOptions } from "./observe-query-selector";
 
@@ -16,9 +17,13 @@ export interface IObservedElementsChanges<T extends Element = Element> {
 /** Returns changes (additions and deletions) of elements that match selectors, like an Rx stream. */
 export function observeQuerySelectorAll<T extends Element = Element>(
     query: string,
-    options: IObserveQuerySelectorOptions = {},
+    options: IObserveQuerySelectorOptions<T> = {},
 ): Observable<IObservedElementsChanges<T>> {
-    const { parent = document.documentElement, asRemovedWhen } = options;
+    const {
+        parent = document.documentElement,
+        asRemovedWhen,
+        filter = trueStub,
+    } = options;
     const targetElements = new Set<T>();
 
     function checkChanges(): Observable<IObservedElementsChanges<T>> {
@@ -30,7 +35,7 @@ export function observeQuerySelectorAll<T extends Element = Element>(
             if (options.has && !querySelectedElement.querySelector(options.has)) {
                 continue;
             }
-            if (options.filter && !options.filter(querySelectedElement)) {
+            if (!filter(querySelectedElement)) {
                 continue;
             }
 

package/src/observable/observe-query-selector.ts

@@ -1,18 +1,22 @@
 
 import { concat, defer, EMPTY, Observable, of } from "rxjs";
 import { distinctUntilChanged, mergeMap, switchMap, throttleTime } from "rxjs/operators";
+import { trueStub } from '../utils/stubs';
 import { observeElementMutation } from "./observe-mutation";
 
-export interface IObserveQuerySelectorOptions<T extends Element = Element> {
+export interface IObserveQuerySelectorBaseOptions<T extends Element = Element> {
     /**
      * The parent element within which changes are tracked.
      * @default document.documentElement
      */
-    parent?: T;
+    parent?: Element;
     /** Checks if the added element has any child elements that match the selectors. */
     has?: string;
     /** Custom validation of each item */
     filter?: (element: T) => boolean;
+}
+
+export interface IObserveQuerySelectorOptions<T extends Element = Element> extends IObserveQuerySelectorBaseOptions<T> {
     /**
      * When the `asRemovedWhen` parameter emits a` true` value,
      * all currently added items will be returned as removed.
@@ -36,9 +40,13 @@ export interface IObserveElementChange<T extends Element = Element> {
  */
 export function observeQuerySelector<T extends Element = Element>(
     query: string,
-    options: IObserveQuerySelectorOptions = {},
+    options: IObserveQuerySelectorOptions<T> = {},
 ): Observable<IObserveElementChange<T>> {
-    const { parent = document.documentElement, asRemovedWhen } = options;
+    const {
+        parent = document.documentElement,
+        asRemovedWhen,
+        filter = trueStub,
+    } = options;
     let targetElement: T | undefined;
 
     function checkChanges(): Observable<IObserveElementChange<T>> {
@@ -50,7 +58,7 @@ export function observeQuerySelector<T extends Element = Element>(
             if (options.has && !querySelectedElement.querySelector(options.has)) {
                 continue;
             }
-            if (options.filter && !options.filter(querySelectedElement)) {
+            if (!filter(querySelectedElement)) {
                 continue;
             }
 

package/src/operators/merge-map-added-elements.ts

@@ -36,11 +36,11 @@ export function mergeMapAddedElements<T extends Element, O extends ObservableInp
     if (!options?.isTakeUntilRemoved) {
         return source$ => source$.pipe(
             mergeMap(changes => {
-                let added = assuredArray(changes.added);
+                const added = assuredArray(changes.added);
                 if (added.length === 0) {
                     return EMPTY;
                 }
-                let addedObservers = added.map(project);
+                const addedObservers = added.map(project);
                 return merge(...addedObservers);
             })
         );
@@ -48,12 +48,12 @@ export function mergeMapAddedElements<T extends Element, O extends ObservableInp
     return source$ => source$.pipe(
         connect(connectedSource$ => connectedSource$.pipe(
             mergeMap(changes => {
-                let added = assuredArray(changes.added);
+                const added = assuredArray(changes.added);
                 if (added.length === 0) {
                     return EMPTY;
                 }
                 
-                let addedObservers = added.map(addedElement => 
+                const addedObservers = added.map(addedElement => 
                     from(
                         project(addedElement)
                     ).pipe(

package/src/operators/merge-map-string-toggle.ts

@@ -18,11 +18,11 @@ export function mergeMapStringToggle<O extends ObservableInput<any>>(
     options?: IMergeMapStringToggleOptions,
 ): OperatorFunction<string, ObservedValueOf<O>> {
     const mapConditionFn = typeof condition === 'function' ? condition : (url: string) => condition.test(url);
-    let urlMatchToggler: (isUrlMatch: Boolean) => Observable<ObservedValueOf<O>>;
+    let urlMatchToggler: (isUrlMatch: boolean) => Observable<ObservedValueOf<O>>;
     if (typeof project === 'function') {
-        urlMatchToggler = (isUrlMatch: Boolean) => isUrlMatch ? from(project()) : EMPTY
+        urlMatchToggler = (isUrlMatch: boolean) => isUrlMatch ? from(project()) : EMPTY;
     } else {
-        urlMatchToggler = (isUrlMatch: Boolean) => isUrlMatch ? from(project) : EMPTY
+        urlMatchToggler = (isUrlMatch: boolean) => isUrlMatch ? from(project) : EMPTY;
     }
     const mergeOperator = options?.isTakeUntilToggle
         ? switchMap(urlMatchToggler)

package/src/operators/restore-history.ts

@@ -0,0 +1,51 @@
+import { concat, defer, EMPTY, ignoreElements, merge, MonoTypeOperatorFunction, NEVER, Observable, ObservableInput, of, share, take, takeUntil, tap } from 'rxjs';
+
+export interface IRestoredHistoryOption<T = unknown> {
+    getStory(): T | undefined;
+    setStory(value: T): void;
+    removeStory(): void;
+    cancelRestore?: () => ObservableInput<unknown>;
+};
+
+export function restoreHistory<T>(
+    options: IRestoredHistoryOption<T>
+): MonoTypeOperatorFunction<T> {
+    return (source$: Observable<T>) => {
+        let hasStory = false;
+        const observeCancel$ = options.cancelRestore
+            ? defer(() => options.cancelRestore!())
+                .pipe(
+                    tap(() => {
+                        if (hasStory) {
+                            options.removeStory();
+                        }
+                    }),
+                    share(),
+                )
+            : NEVER;
+        const story$ = concat(
+            defer(() => {
+                const story = options.getStory();
+                if (story === undefined) {
+                    return EMPTY;
+                }
+                hasStory = true;
+                let rested$ = of(story);
+                if (options.cancelRestore) {
+                    rested$ = rested$.pipe(takeUntil(observeCancel$))
+                }
+                return rested$;
+            }),
+            source$.pipe(
+                tap((data: T) => {
+                    options.setStory(data);
+                    hasStory = true;
+                }),
+            ),
+        );
+        return merge(
+            story$,
+            observeCancel$.pipe(ignoreElements())
+        );
+    }
+}

package/src/utils/compose-restore-history.ts

@@ -0,0 +1,61 @@
+import { merge, MonoTypeOperatorFunction, ReplaySubject } from 'rxjs';
+import { IRestoredHistoryOption, restoreHistory } from '../operators/restore-history';
+
+export type ComposedRestoredHistoryOptionList<T extends IRestoredHistoryOption = IRestoredHistoryOption> = readonly T[] | Record<string, T>;
+
+export type ComposedRestoredHistoryOperatorsRecord<T extends Record<string, IRestoredHistoryOption>> = {
+    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
+        ? MonoTypeOperatorFunction<Input>
+        : never;
+}
+
+export type ComposedRestoredHistoryOperatorsArray<T extends readonly IRestoredHistoryOption[]> = {
+    [P in keyof T]: T[P] extends IRestoredHistoryOption<infer Input>
+        ? MonoTypeOperatorFunction<Input>
+        : never;
+}
+
+export type ComposedRestoredHistoryOperatorsList<T extends ComposedRestoredHistoryOptionList>
+    = T extends Array<any>
+        ? ComposedRestoredHistoryOperatorsArray<T>
+        : T extends Record<string, any>
+            ? ComposedRestoredHistoryOperatorsRecord<T>
+            : never;
+
+export interface IComposedRestoredHistory<T extends ComposedRestoredHistoryOptionList> {
+    operators: ComposedRestoredHistoryOperatorsList<T>;
+    cancelAll: () => void;
+}
+
+export function composeRestoreHistory<T extends ComposedRestoredHistoryOptionList>(
+    options: T,
+): IComposedRestoredHistory<T> {
+    const cancelSubject$ = new ReplaySubject<void>(1);
+    function cancelAll(): void {
+        cancelSubject$.next();
+    }
+    function convertOption(option: IRestoredHistoryOption): MonoTypeOperatorFunction<unknown> {
+        return restoreHistory({
+            ...option,
+            cancelRestore: !!option.cancelRestore
+                ? () => merge(
+                    cancelSubject$,
+                    option.cancelRestore!(),
+                )
+                : () => cancelSubject$,
+        });
+    }
+    let operators: ComposedRestoredHistoryOperatorsList<T>;
+    if (options instanceof Array) {
+        operators = options.map(convertOption) as readonly MonoTypeOperatorFunction<any>[] as ComposedRestoredHistoryOperatorsList<T>;
+    } else {
+        operators = {} as Record<string, MonoTypeOperatorFunction<any>> as ComposedRestoredHistoryOperatorsList<T>;
+        for (const key of Object.keys(options)) {
+            (operators as Record<string, MonoTypeOperatorFunction<any>>)[key] = convertOption(options[key]);
+        }        
+    }
+    return {
+        operators: operators as ComposedRestoredHistoryOperatorsList<T>,
+        cancelAll,
+    };
+}

package/src/utils/find-recursively.ts

@@ -1,43 +1,196 @@
-export type RecursivelyFindMather = (propertyName: string, value: unknown, path: string) => boolean;
+import { falseStub, trueStub } from './stubs';
 
-export function findRecursively(obj: unknown, mather: RecursivelyFindMather): Record<string, unknown> | null {
-    const seen = new Set<unknown>();
+export interface IFindRecursivelyMatherOptions {
+    field?: unknown;
+    value: unknown;
+    path?: string;
+    depth: number;
+}
+
+export type FindRecursivelyMatcher = (options: Readonly<IFindRecursivelyMatherOptions>) => boolean;
+export type FindRecursivelyContinue = (result: Readonly<FindRecursivelyResult>) => boolean;
+export type FindRecursivelyResult = Record<string, unknown> | null;
+
+export interface IFindRecursivelyOptions {
+    /**
+     * Checking a field for compliance with conditions  
+     * If the method returns `true`, then the field will be added to the result list
+     */
+    matcher?: FindRecursivelyMatcher;
+    /**
+     * Filtering out the need for recursive field validation.
+     * * If the method returns `true`, then all child fields will be checked recursively.
+     * * If the method returns `false`, then the field is excluded from recursive validation.
+     */
+    filter?: FindRecursivelyMatcher;
+    /**
+     * Checking whether to continue searching. This check occurs after each new found field.
+     * * If the method returns `true`, then the recursive search terminates immediately.
+     * * If the method returns `false`, then the recursive search will continue.
+     */
+    stop?: FindRecursivelyContinue;
+    /** Regular expression to match with a constructed path */
+    pathRegExp?: RegExp;
+    /** Regular expression to match with a constructed path */
+    fieldRegExp?: RegExp;
+    /** Maximum depth of recursive search */
+    maxDepth?: number;
+    //** Minimum depth of recursive search */
+    minDepth?: number;
+    /**
+     * Checking getter fields
+     * * If the value is `true`, then the field getter will not be called to get the result.
+     * Accordingly, the result of the getter will not be checked.
+     * * If the value is `false`, then the field getter will be called to get the result.
+     * Getter result will be checked
+     */
+    isIgnoreGetters?: boolean;
+    /**
+     * Error handling when getting a result from a getter method.
+     * * If the method returns `true`, then the recursive search will continue.
+     * * If the method returns `false`, then the recursive search terminates immediately.
+     */
+    continueAfterGetterError?: (error: unknown) => boolean;
+}
+
+
+
+/** Recursive search on entity fields */
+export function findRecursively(obj: unknown, options: IFindRecursivelyOptions = {}): FindRecursivelyResult {
+    /** {value: path[]} */
+    const seen = new Map<unknown, Array<string | undefined>>();
     const searched: Record<string, unknown> = {};
-    const needFind = new Set<[path: string | undefined, value: unknown]>([[undefined, obj]]);
+    const needSeen = new Set<IFindRecursivelyMatherOptions>([{
+        value: obj,
+        depth: 0,
+    }]);
+    const {
+        matcher = falseStub,
+        filter = trueStub,
+        continueAfterGetterError = trueStub,
+        stop = falseStub,
+        minDepth = 1,
+        maxDepth = Infinity,
+    } = options;
+    const pathRegExpCheck =  options.pathRegExp
+        ? (path?: string) => path ? options.pathRegExp?.test(path) : false
+        : falseStub;
+    const fieldRegExpCheck =  options.fieldRegExp
+        ? (field?: unknown) => typeof field === 'string' ? options.fieldRegExp?.test(field) : false
+        : falseStub;
+    let needStop: boolean = false;
 
-    function addToCheck(path: string, value: unknown) {
-        if (seen.has(value) ) {
+    function checkForNeedSeen(options: IFindRecursivelyMatherOptions) {
+        if (options.depth > maxDepth) {
+            return;
+        }
+        const isPrimitiveOrFunction = options.value === null || typeof options.value !== 'object';
+        if (!isPrimitiveOrFunction) {
+            const seenPathsForValue: Array<string | undefined> | undefined = seen.get(options.value);
+            if (seenPathsForValue) {
+                // TODO windows or document
+                // TODO List of visited objects, but with the wrong path
+                const hasCircularPath = seenPathsForValue.some(path => options.path && path?.includes(options.path));
+                if (hasCircularPath) {
+                    return;
+                }
+            }
+            if (filter(options)) {
+                needSeen.add(options);
+                if (seenPathsForValue) {
+                    seenPathsForValue.push(options.path);
+                } else {
+                    seen.set(options.value, [options.path]);
+                }
+            }
+        }
+        if (options.depth < minDepth) {
             return;
         }
-        needFind.add([path, value]);
-        seen.add(value);
+        if (matcher(options) || pathRegExpCheck(options.path) || fieldRegExpCheck(options.field)) {
+            searched[options.path || '{}'] = options.value;
+            if (stop(searched)) {
+                needStop = true;
+            }
+        }
+    }
+
+    function iterateArrayLike(
+        iterator: IterableIterator<[unknown, unknown]>,
+        pathBuilder: (fieldIndex: unknown) => string,
+        incrementalDepth: number,
+    ): void {
+        for (const [fieldIndex, fieldValue] of iterator) {
+            checkForNeedSeen({
+                field: fieldIndex,
+                value: fieldValue,
+                path: pathBuilder(fieldIndex),
+                depth: incrementalDepth,
+            });
+            if (needStop) {
+                return;
+            }
+        }
     }
 
-    while (true) {
-        const iterator = needFind.values().next();
+    while (!needStop) {
+        const iterator = needSeen.values().next();
         if (iterator.done) {
             break;
         }
-        const path = iterator.value[0];
-        const iteratedObj = iterator.value[1];
-        needFind.delete(iterator.value);
+        const {value, path, depth} = iterator.value;
+        const incrementalDepth = depth + 1;
+        needSeen.delete(iterator.value);
 
-        if (!iteratedObj) {
-            continue;
-        }
-        if (iteratedObj instanceof Array) {
-            for (const [index, value] of (iteratedObj as unknown[]).entries()) {
-                if (value )
-                addToCheck(`${path || ''}[${index}]`, value);
+        if (value instanceof Array) {
+            iterateArrayLike(
+                (value as unknown[]).entries(),
+                (fieldIndex) => `${path || ''}[${fieldIndex}]`,
+                incrementalDepth,
+            );
+        } if (value instanceof Map) {
+            iterateArrayLike(
+                (value as Map<unknown, unknown>).entries(),
+                (fieldIndex) => `${path || ''}{${fieldIndex}}`,
+                incrementalDepth,
+            );
+        } if (value instanceof Set) {
+            for (const [fieldIndex, fieldValue] of ([...value] as unknown[]).entries()) {
+                checkForNeedSeen({
+                    field: fieldValue,
+                    value: fieldValue,
+                    path: `${path || ''}<${fieldIndex}>`,
+                    depth: incrementalDepth,
+                });
+                if (needStop) {
+                    break;
+                }
             }
-        } else if (typeof iteratedObj === "object") {
-            for (const key of Object.keys(iteratedObj as object)) {
-                const value: unknown = (iteratedObj as any)[key];
-                const keyPath = path ? `${path}.${key}` : key;
-                if (mather(key, value, keyPath)) {
-                    searched[keyPath] = value;
+        } else if (typeof value === "object") {
+            for (const key of Object.keys(value as object)) {
+                let fieldValue: unknown;
+                if (Object.getOwnPropertyDescriptor(value, key)?.get && options.isIgnoreGetters) {
+                    continue;
+                }
+                try {
+                    fieldValue = (value as any)[key];
+                } catch (error: unknown) {
+                    if (!continueAfterGetterError(error)) {
+                        needStop = true;
+                        break;
+                    }
+                    fieldValue = error;
+                }
+
+                checkForNeedSeen({
+                    field: key,
+                    value: fieldValue,
+                    path: path ? `${path}.${key}` : key,
+                    depth: incrementalDepth
+                });
+                if (needStop) {
+                    break;
                 }
-                addToCheck(keyPath, value);
             }
         }
     }
@@ -47,7 +200,3 @@ export function findRecursively(obj: unknown, mather: RecursivelyFindMather): Re
     }
     return searched;
 }
-
-export function findRecursivelyPropertyName(obj: unknown, propertyName: string): Record<string, unknown> | null {
-    return findRecursively(obj, matchedPropertyName => matchedPropertyName === propertyName);
-}

package/src/utils/stubs.ts

@@ -0,0 +1,7 @@
+export function trueStub(): true {
+    return true;
+}
+
+export function falseStub(): false {
+    return false;
+}