@plohoj/html-editor 0.0.7 → 0.1.0

package/dist/index.js

@@ -1,5 +1,73 @@
-import { throttleTime, mergeMap, distinctUntilChanged, switchMap, debounceTime, filter, map, take, tap, shareReplay, connect, takeUntil } from 'rxjs/operators';
-import { Observable, concat, defer, EMPTY, of, merge, fromEvent, from, pipe, tap as tap$1, share, NEVER, takeUntil as takeUntil$1, ignoreElements, ReplaySubject } from 'rxjs';
+import { mergeMap, EMPTY, merge, connect, filter, takeUntil, Observable, concat, defer, throttleTime, distinctUntilChanged, switchMap, of, debounceTime, map, take, fromEvent, tap, shareReplay, share, NEVER, ignoreElements, ReplaySubject } from 'rxjs';
+import { __rest } from 'tslib';
+
+function assuredArray(values) {
+    if (values instanceof Array) {
+        return values;
+    }
+    if (values) {
+        return [values];
+    }
+    return [];
+}
+function mergeMapAddedElements(projectOrOptions, options) {
+    // #region Options parsing
+    let project;
+    let stableOptions;
+    if (typeof projectOrOptions === 'function') {
+        project = projectOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        project = projectOrOptions.project;
+        stableOptions = projectOrOptions;
+    }
+    const { takeUntil: takeUntilOption = 'removed' } = stableOptions;
+    // #endregion
+    if (takeUntilOption === 'always') {
+        return source$ => source$.pipe(mergeMap(changes => {
+            const added = assuredArray(changes.added);
+            if (added.length === 0) {
+                return EMPTY;
+            }
+            const addedObservers = added.map(project);
+            return merge(...addedObservers);
+        }));
+    }
+    return source$ => source$.pipe(connect(connectedSource$ => connectedSource$.pipe(mergeMap(changes => {
+        const added = assuredArray(changes.added);
+        if (added.length === 0) {
+            return EMPTY;
+        }
+        const addedObservers = added.map(addedElement => {
+            let takeUntil$;
+            if (takeUntilOption === 'removed') {
+                takeUntil$ = connectedSource$.pipe(filter(connectedChanges => connectedChanges.removed instanceof Array
+                    ? connectedChanges.removed.indexOf(addedElement) !== -1
+                    : connectedChanges.removed === addedElement));
+            }
+            else {
+                let wasRemoved = false;
+                takeUntil$ = connectedSource$.pipe(filter(connectedChanges => {
+                    if (!wasRemoved) {
+                        wasRemoved = connectedChanges.removed instanceof Array
+                            ? connectedChanges.removed.indexOf(addedElement) !== -1
+                            : connectedChanges.removed === addedElement;
+                    }
+                    if (wasRemoved) {
+                        const hasTarget = connectedChanges.target instanceof Array
+                            ? connectedChanges.target.indexOf(addedElement) !== -1
+                            : connectedChanges.target === addedElement;
+                        return hasTarget;
+                    }
+                    return false;
+                }));
+            }
+            return project(addedElement).pipe(takeUntil(takeUntil$));
+        });
+        return merge(...addedObservers);
+    }))));
+}
 
 function trueStub() {
     return true;
@@ -8,9 +76,7 @@ function falseStub() {
     return false;
 }
 
-/**
- * Converts the callback of the MutationObserver class to an Rx event stream
- */
+/** Converts the callback of the {@link MutationObserver} class to an Rx event stream */
 function observeElementMutation(node, options) {
     return new Observable(subscriber => {
         const mutationObserver = new MutationObserver(mutation => subscriber.next(mutation));
@@ -19,18 +85,36 @@ 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, filter = trueStub, } = options;
+function observeQuerySelector(queryOrOptions, projectOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let project;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        if (typeof projectOrOptions === 'function') {
+            project = projectOrOptions;
+            stableOptions = options || {};
+        }
+        else {
+            stableOptions = projectOrOptions || {};
+            project = projectOrOptions === null || projectOrOptions === void 0 ? void 0 : projectOrOptions.project;
+        }
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+        project = queryOrOptions === null || queryOrOptions === void 0 ? void 0 : queryOrOptions.project;
+    }
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, has, tap } = stableOptions, restOfStableOptions = __rest(stableOptions, ["parent", "asRemovedWhen", "filter", "has", "tap"]);
+    // #endregion
     let targetElement;
     function checkChanges() {
         const querySelectedElements = parent.querySelectorAll(query);
         let filteredSelectedElement;
         const changes = {};
         for (const querySelectedElement of querySelectedElements) {
-            if (options.has && !querySelectedElement.querySelector(options.has)) {
+            if (has && !querySelectedElement.querySelector(has)) {
                 continue;
             }
             if (!filter(querySelectedElement)) {
@@ -47,12 +131,14 @@ function observeQuerySelector(query, options = {}) {
         }
         if (filteredSelectedElement) {
             changes.added = filteredSelectedElement;
+            tap === null || tap === void 0 ? void 0 : tap(filteredSelectedElement);
         }
         changes.target = filteredSelectedElement;
         targetElement = filteredSelectedElement;
         return of(changes);
     }
     const observeQuerySelector$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    let observeQuerySelectorWithRemovedWhen$ = observeQuerySelector$;
     if (asRemovedWhen) {
         const removedObserver$ = defer(() => {
             if (!targetElement) {
@@ -64,30 +150,60 @@ function observeQuerySelector(query, options = {}) {
             targetElement = undefined;
             return of(changes);
         });
-        const observeQuerySelectorWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelector$));
-        return observeQuerySelectorWithRemovedWhen$;
+        observeQuerySelectorWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelector$));
     }
-    return observeQuerySelector$;
+    if (project) {
+        return observeQuerySelectorWithRemovedWhen$.pipe(mergeMapAddedElements(Object.assign({ project }, restOfStableOptions)));
+    }
+    return observeQuerySelectorWithRemovedWhen$;
 }
 
-/**
- * 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 awaitElement(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelector(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
 }
 
-/** Returns changes (additions and deletions) of elements that match selectors, like an Rx stream. */
-function observeQuerySelectorAll(query, options = {}) {
-    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, } = options;
+function observeQuerySelectorAll(queryOrOptions, projectOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let project;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        if (typeof projectOrOptions === 'function') {
+            project = projectOrOptions;
+            stableOptions = options || {};
+        }
+        else {
+            stableOptions = projectOrOptions || {};
+            project = projectOrOptions === null || projectOrOptions === void 0 ? void 0 : projectOrOptions.project;
+        }
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+        project = queryOrOptions === null || queryOrOptions === void 0 ? void 0 : queryOrOptions.project;
+    }
+    const { parent = document.documentElement, asRemovedWhen, filter = trueStub, has, tap } = stableOptions, restOfStableOptions = __rest(stableOptions, ["parent", "asRemovedWhen", "filter", "has", "tap"]);
+    // #endregion
     const targetElements = new Set();
     function checkChanges() {
         const addedElements = new Set();
         const targetElementsDiff = new Set(targetElements);
         const querySelectedElements = new Set(parent.querySelectorAll(query));
         for (const querySelectedElement of querySelectedElements) {
-            if (options.has && !querySelectedElement.querySelector(options.has)) {
+            if (has && !querySelectedElement.querySelector(has)) {
                 continue;
             }
             if (!filter(querySelectedElement)) {
@@ -109,6 +225,7 @@ function observeQuerySelectorAll(query, options = {}) {
         }
         for (const addedElement of addedElements) {
             targetElements.add(addedElement);
+            tap === null || tap === void 0 ? void 0 : tap(addedElement);
         }
         const changes = {
             target: [...targetElements.values()],
@@ -117,7 +234,8 @@ function observeQuerySelectorAll(query, options = {}) {
         };
         return of(changes);
     }
-    let observeQuerySelectorAll$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    const observeQuerySelectorAll$ = concat(defer(() => checkChanges()), observeElementMutation(parent, { subtree: true, childList: true }).pipe(throttleTime(0, undefined, { leading: true, trailing: true }), mergeMap(checkChanges)));
+    let observeQuerySelectorAllWithRemovedWhen$ = observeQuerySelectorAll$;
     if (asRemovedWhen) {
         const removedObserver$ = defer(() => {
             if (targetElements.size === 0) {
@@ -131,18 +249,28 @@ function observeQuerySelectorAll(query, options = {}) {
             targetElements.clear();
             return of(changes);
         });
-        const observeQuerySelectorAllWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelectorAll$));
-        return observeQuerySelectorAllWithRemovedWhen$;
+        observeQuerySelectorAllWithRemovedWhen$ = asRemovedWhen.pipe(distinctUntilChanged(), switchMap(asRemoved => asRemoved ? removedObserver$ : observeQuerySelectorAll$));
+    }
+    if (project) {
+        return observeQuerySelectorAllWithRemovedWhen$.pipe(mergeMapAddedElements(Object.assign({ project }, restOfStableOptions)));
     }
-    return observeQuerySelectorAll$;
+    return observeQuerySelectorAllWithRemovedWhen$;
 }
 
-/**
- * Awaiting only first elements changes to match the selector and returns it as an Rx stream.
- * The stream ends after any element is found / added.
- */
-function awaitElements(query, options = {}) {
-    return observeQuerySelectorAll(query, options).pipe(debounceTime(options.debounceTime || 0, options.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
+function awaitElements(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelectorAll(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => !!changes.target), map(changes => changes.target), take(1));
 }
 
 function randomFromArray(array, from = 0, to = array.length) {
@@ -152,13 +280,20 @@ function randomFromArray(array, from = 0, to = array.length) {
     return array[Math.floor(Math.random() * (to - from)) + from];
 }
 
-/**
- * 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.
- */
-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 awaitRandomElement(queryOrOptions, options) {
+    // #region Options parsing
+    let query;
+    let stableOptions;
+    if (typeof queryOrOptions === 'string') {
+        query = queryOrOptions;
+        stableOptions = options || {};
+    }
+    else {
+        stableOptions = queryOrOptions;
+        query = queryOrOptions.query;
+    }
+    // #endregion
+    return observeQuerySelectorAll(query, stableOptions).pipe(debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler), filter(changes => changes.target.length > 0), map(changes => randomFromArray(changes.target)), take(1));
 }
 
 function observePressedKeyboardButtons(options = {}) {
@@ -196,6 +331,82 @@ const urlChange$ = new Observable(subscriber$ => {
     };
 }).pipe(distinctUntilChanged(), shareReplay(1));
 
+function mergeMapByCondition(conditionOrOptions, project, options) {
+    // #region Options parsing
+    let stableOptions;
+    let conditionFn;
+    let stableProject;
+    if ('condition' in conditionOrOptions) {
+        stableOptions = conditionOrOptions;
+        conditionFn = conditionOrOptions.condition;
+        stableProject = conditionOrOptions.project;
+    }
+    else {
+        conditionFn = conditionOrOptions;
+        stableOptions = options || {};
+        stableProject = project;
+    }
+    const { takeFor = 'new', takeUntil: takeUntilOption = 'fail', } = stableOptions;
+    // #endregion
+    let isPrevConditionPass = false;
+    return source$ => source$.pipe(map(source => ({ source, isConditionPassed: conditionFn(source) })), connect(connectedSource$ => {
+        let takeUntil$;
+        if (takeUntilOption === 'fail') {
+            takeUntil$ = connectedSource$.pipe(filter(({ isConditionPassed }) => isConditionPassed));
+        }
+        else if (takeUntilOption === 'pass') {
+            let wasFailed = false;
+            takeUntil$ = connectedSource$.pipe(filter(({ isConditionPassed }) => {
+                if (isConditionPassed) {
+                    if (wasFailed) {
+                        return true;
+                    }
+                }
+                else {
+                    wasFailed = true;
+                }
+                return false;
+            }));
+        }
+        return connectedSource$.pipe(mergeMap(({ source, isConditionPassed }) => {
+            if (isConditionPassed) {
+                const isCreateNewProject = takeFor === 'all' || !isPrevConditionPass;
+                isPrevConditionPass = true;
+                if (isCreateNewProject) {
+                    if (!stableProject) {
+                        return of(source);
+                    }
+                    let project$ = stableProject(source);
+                    if (takeUntil$) {
+                        project$ = project$.pipe(takeUntil(takeUntil$));
+                    }
+                    return project$;
+                }
+            }
+            else {
+                isPrevConditionPass = false;
+            }
+            return EMPTY;
+        }));
+    }));
+}
+
+function getStringConditionFunction(condition) {
+    return typeof condition === 'function' ? condition : (value) => condition.test(value);
+}
+function mergeMapStringCondition(conditionOrOptions, project, options) {
+    if ('condition' in conditionOrOptions) {
+        return mergeMapByCondition(Object.assign(Object.assign({}, conditionOrOptions), { condition: getStringConditionFunction(conditionOrOptions.condition) }));
+    }
+    else {
+        return mergeMapByCondition(Object.assign(Object.assign({}, options), { condition: getStringConditionFunction(conditionOrOptions), project }));
+    }
+}
+
+function observeUrlChanges(options = {}) {
+    return urlChange$.pipe(mergeMapStringCondition(Object.assign(Object.assign({}, options), { condition: options.condition || (() => true) })));
+}
+
 function clickElementImmediately(element) {
     if ('click' in element) {
         element.click();
@@ -233,60 +444,6 @@ function focusElement(element) {
     }
 }
 
-function assuredArray(values) {
-    if (values instanceof Array) {
-        return values;
-    }
-    if (values) {
-        return [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)) {
-        return source$ => source$.pipe(mergeMap(changes => {
-            const added = assuredArray(changes.added);
-            if (added.length === 0) {
-                return EMPTY;
-            }
-            const addedObservers = added.map(project);
-            return merge(...addedObservers);
-        }));
-    }
-    return source$ => source$.pipe(connect(connectedSource$ => connectedSource$.pipe(mergeMap(changes => {
-        const added = assuredArray(changes.added);
-        if (added.length === 0) {
-            return EMPTY;
-        }
-        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;
-            }
-            else {
-                return changes.removed === addedElement;
-            }
-        })))));
-        return merge(...addedObservers);
-    }))));
-}
-
-/** 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 tap((element) => {
         element.remove();
@@ -299,7 +456,7 @@ function restoreHistory(options) {
         let hasStory = false;
         const observeCancel$ = options.cancelRestore
             ? defer(() => options.cancelRestore())
-                .pipe(tap$1(() => {
+                .pipe(tap(() => {
                 if (hasStory) {
                     options.removeStory();
                 }
@@ -313,10 +470,10 @@ function restoreHistory(options) {
             hasStory = true;
             let rested$ = of(story);
             if (options.cancelRestore) {
-                rested$ = rested$.pipe(takeUntil$1(observeCancel$));
+                rested$ = rested$.pipe(takeUntil(observeCancel$));
             }
             return rested$;
-        }), source$.pipe(tap$1((data) => {
+        }), source$.pipe(tap((data) => {
             options.setStory(data);
             hasStory = true;
         })));
@@ -493,5 +650,5 @@ function findRecursively(obj, options = {}) {
     return searched;
 }
 
-export { awaitElement, awaitElements, awaitRandomElement, clickElement, composeRestoreHistory, findRecursively, focusElement, mergeMapAddedElements, mergeMapStringToggle, observeElementMutation, observePressedKeyboardButtons, observeQuerySelector, observeQuerySelectorAll, randomFromArray, removeElement, restoreHistory, setInputValue, urlChange$ };
+export { awaitElement, awaitElements, awaitRandomElement, clickElement, composeRestoreHistory, findRecursively, focusElement, mergeMapAddedElements, mergeMapByCondition, mergeMapStringCondition, observeElementMutation, observePressedKeyboardButtons, observeQuerySelector, observeQuerySelectorAll, observeUrlChanges, 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,25 +1,25 @@
-{
-  "name": "@plohoj/html-editor",
-  "version": "0.0.7",
-  "description": "html-editor it's a tool for helping modification html elements",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/plohoj/html-editor.git"
-  },
-  "scripts": {
-    "build": "rollup --config"
-  },
-  "author": "Plokhikh Alexandr",
-  "license": "ISC",
-  "module": "./dist/index.js",
-  "types": "./src/index.ts",
-  "type": "module",
-  "dependencies": {
-    "rxjs": "^7.0.0"
-  },
-  "devDependencies": {
-    "rollup": "^3.9.1",
-    "rollup-plugin-typescript2": "^0.34.1",
-    "typescript": "^4.9.4"
-  }
-}
+{
+  "name": "@plohoj/html-editor",
+  "version": "0.1.0",
+  "description": "html-editor it's a tool for helping modification html elements",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plohoj/html-editor.git"
+  },
+  "scripts": {
+    "build": "rollup --config"
+  },
+  "author": "Plokhikh Alexandr",
+  "license": "ISC",
+  "module": "./dist/index.js",
+  "types": "./src/index.ts",
+  "type": "module",
+  "dependencies": {
+    "rxjs": "^7.0.0"
+  },
+  "devDependencies": {
+    "rollup": "^3.9.1",
+    "rollup-plugin-typescript2": "^0.34.1",
+    "typescript": "^4.9.4"
+  }
+}

package/src/index.ts

@@ -1,23 +1,25 @@
-// Observable
-export { awaitElement, IAwaitElementOptions } from "./observable/await-element";
-export { awaitElements } from './observable/await-elements';
-export { awaitRandomElement } from './observable/await-random-element';
-export { observeElementMutation } from "./observable/observe-mutation";
-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 { focusElement } from './operators/focus-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";
-
-// Utils
-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";
+// Observable
+export { awaitElement, IAwaitElementOptions } from "./observable/await-element";
+export { awaitElements } from './observable/await-elements';
+export { awaitRandomElement } from './observable/await-random-element';
+export { observeElementMutation } from "./observable/observe-mutation";
+export { IObservePressedKeyboardButtonsOptions, observePressedKeyboardButtons } from './observable/observe-pressed-keyboard-buttons';
+export { IObservedElementChange, 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 { observeUrlChanges } from './observable/observe-url-changes';
+export { clickElement } from "./operators/click-element";
+export { focusElement } from './operators/focus-element';
+export { mergeMapAddedElements } from "./operators/merge-map-added-elements";
+export { mergeMapByCondition } from './operators/merge-map-by-condition';
+export { mergeMapStringCondition } from "./operators/merge-map-by-string-condition";
+export { removeElement } from "./operators/remove-element";
+export { IRestoredHistoryOption, restoreHistory } from './operators/restore-history';
+export { setInputValue } from "./operators/set-input-value";
+
+// Utils
+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,29 +1,47 @@
-import { Observable, SchedulerLike } from "rxjs";
-import { debounceTime, filter, map, take } from "rxjs/operators";
-import { IObserveQuerySelectorBaseOptions, observeQuerySelector } from "./observe-query-selector";
-
-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 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 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 => changes.target!),
-        take(1),
-    );
-}
+import { Observable, SchedulerLike, debounceTime, filter, map, take } from "rxjs";
+import { IObserveQuerySelectorBaseOptions, observeQuerySelector } from "./observe-query-selector";
+
+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 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 awaitElement<T extends Element = Element>(
+  options: IAwaitElementOptions<T>,
+): Observable<T>;
+export function awaitElement<T extends Element = Element>(
+  query: string,
+  options?: Omit<IAwaitElementOptions<T>, 'query'>,
+): Observable<T>;
+export function awaitElement<T extends Element = Element>(
+  queryOrOptions: string | IAwaitElementOptions<T>,
+  options?: Omit<IAwaitElementOptions<T>, 'query'>,
+): Observable<T> {
+  // #region Options parsing
+  let query: string;
+  let stableOptions: Omit<IAwaitElementOptions<T>, 'query'>;
+  if (typeof queryOrOptions === 'string') {
+    query = queryOrOptions;
+    stableOptions = options || {};
+  } else {
+    stableOptions = queryOrOptions;
+    query = queryOrOptions.query;
+  }
+  // #endregion
+
+  return observeQuerySelector<T>(query, stableOptions).pipe(
+    debounceTime(stableOptions.debounceTime || 0, stableOptions.debounceScheduler),
+    filter(changes => !!changes.target),
+    map(changes => changes.target!),
+    take(1),
+  );
+}