extra-react-hooks 0.3.2 → 0.3.3

package/dist/es2018/index.mjs

@@ -2560,7 +2560,7 @@ var customError$1 = {};
 
 var es2018$a = {};
 
-var middleware$1 = {};
+var middleware = {};
 
 var chunkAsync$2 = {};
 
@@ -4712,7 +4712,7 @@ function* zipWithSize$2(...iterables) {
 var hasRequiredMiddleware;
 
 function requireMiddleware () {
-	if (hasRequiredMiddleware) return middleware$1;
+	if (hasRequiredMiddleware) return middleware;
 	hasRequiredMiddleware = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -4776,11 +4776,11 @@ function requireMiddleware () {
 		__exportStar(zipAsync$3, exports);
 		__exportStar(zip$7, exports);
 		
-} (middleware$1));
-	return middleware$1;
+} (middleware));
+	return middleware;
 }
 
-var output$1 = {};
+var output = {};
 
 var consume$3 = {};
 
@@ -4968,10 +4968,10 @@ function includes$2(iterable, value) {
 }
 includes$3.includes = includes$2;
 
-var matchAsync$3 = {};
+var matchAsync$1 = {};
 
-matchAsync$3.matchAsync = void 0;
-async function matchAsync$2(iterable, sequence) {
+matchAsync$1.matchAsync = void 0;
+async function matchAsync(iterable, sequence) {
     const sequenceLength = sequence.length;
     let matchCount = 0;
     for await (const element of iterable) {
@@ -4982,12 +4982,12 @@ async function matchAsync$2(iterable, sequence) {
     }
     return false;
 }
-matchAsync$3.matchAsync = matchAsync$2;
+matchAsync$1.matchAsync = matchAsync;
 
-var match$3 = {};
+var match$1 = {};
 
-match$3.match = void 0;
-function match$2(iterable, sequence) {
+match$1.match = void 0;
+function match(iterable, sequence) {
     const sequenceLength = sequence.length;
     let matchCount = 0;
     for (const element of iterable) {
@@ -4998,7 +4998,7 @@ function match$2(iterable, sequence) {
     }
     return false;
 }
-match$3.match = match$2;
+match$1.match = match;
 
 var reduceAsync$3 = {};
 
@@ -5233,12 +5233,12 @@ function last$5(iterable) {
 }
 last$6.last = last$5;
 
-var toArrayAsync$4 = {};
+var toArrayAsync$3 = {};
 
-toArrayAsync$4.toArrayAsync = void 0;
-const consume_1$7 = consume$3;
-function toArrayAsync$3(iterable) {
-    return (0, consume_1$7.consume)(iterable, async (iterable) => {
+toArrayAsync$3.toArrayAsync = void 0;
+const consume_1$3 = consume$3;
+function toArrayAsync$2(iterable) {
+    return (0, consume_1$3.consume)(iterable, async (iterable) => {
         const result = [];
         for await (const element of iterable) {
             result.push(element);
@@ -5246,23 +5246,23 @@ function toArrayAsync$3(iterable) {
         return result;
     });
 }
-toArrayAsync$4.toArrayAsync = toArrayAsync$3;
+toArrayAsync$3.toArrayAsync = toArrayAsync$2;
 
 var toArray$5 = {};
 
 toArray$5.toArray = void 0;
-const consume_1$6 = consume$3;
+const consume_1$2 = consume$3;
 function toArray$4(iterable) {
-    return (0, consume_1$6.consume)(iterable, iterable => Array.from(iterable));
+    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
 }
 toArray$5.toArray = toArray$4;
 
 var toSetAsync$3 = {};
 
 toSetAsync$3.toSetAsync = void 0;
-const consume_1$5 = consume$3;
+const consume_1$1 = consume$3;
 function toSetAsync$2(iterable) {
-    return (0, consume_1$5.consume)(iterable, async (iterable) => {
+    return (0, consume_1$1.consume)(iterable, async (iterable) => {
         const result = new Set();
         for await (const element of iterable) {
             result.add(element);
@@ -5275,9 +5275,9 @@ toSetAsync$3.toSetAsync = toSetAsync$2;
 var toSet$3 = {};
 
 toSet$3.toSet = void 0;
-const consume_1$4 = consume$3;
+const consume_1 = consume$3;
 function toSet$2(iterable) {
-    return (0, consume_1$4.consume)(iterable, iterable => new Set(iterable));
+    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
 }
 toSet$3.toSet = toSet$2;
 
@@ -5330,22 +5330,22 @@ countAsync$3.countAsync = countAsync$2;
 	__exportStar(first$5, exports);
 	__exportStar(includesAsync$3, exports);
 	__exportStar(includes$3, exports);
-	__exportStar(matchAsync$3, exports);
-	__exportStar(match$3, exports);
+	__exportStar(matchAsync$1, exports);
+	__exportStar(match$1, exports);
 	__exportStar(reduceAsync$3, exports);
 	__exportStar(reduce$5, exports);
 	__exportStar(someAsync$3, exports);
 	__exportStar(some$3, exports);
 	__exportStar(lastAsync$3, exports);
 	__exportStar(last$6, exports);
-	__exportStar(toArrayAsync$4, exports);
+	__exportStar(toArrayAsync$3, exports);
 	__exportStar(toArray$5, exports);
 	__exportStar(toSetAsync$3, exports);
 	__exportStar(toSet$3, exports);
 	__exportStar(count$5, exports);
 	__exportStar(countAsync$3, exports);
 	
-} (output$1));
+} (output));
 
 var hasRequiredEs2018;
 
@@ -5367,7 +5367,7 @@ function requireEs2018 () {
 		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 		};__exportStar(requireMiddleware(), exports);
-		__exportStar(output$1, exports);
+		__exportStar(output, exports);
 		
 } (es2018$a));
 	return es2018$a;
@@ -5576,7 +5576,7 @@ function useSingleSelection(options, defaultSelectedIndex) {
 
 var es2018$5 = {};
 
-var middleware = {};
+var intermediate = {};
 
 var chunkAsync$1 = {};
 
@@ -6340,6 +6340,91 @@ function concat$4(iterable, ...otherIterables) {
 }
 concat$5.concat = concat$4;
 
+var differenceAsync$1 = {};
+
+var filterAsync$1 = {};
+
+filterAsync$1.filterAsync = void 0;
+const types_1$g = es2018$1;
+function filterAsync(iterable, predicate) {
+    if ((0, types_1$g.isAsyncIterable)(iterable)) {
+        return filterAsyncIterable(iterable, predicate);
+    }
+    else {
+        return filterIterable(iterable, predicate);
+    }
+}
+filterAsync$1.filterAsync = filterAsync;
+async function* filterAsyncIterable(iterable, predicate) {
+    let index = 0;
+    for await (const element of iterable) {
+        if (await predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+async function* filterIterable(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (await predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+
+var toSetAsync$1 = {};
+
+toSetAsync$1.toSetAsync = void 0;
+async function toSetAsync(iterable) {
+    const result = new Set();
+    for await (const element of iterable) {
+        result.add(await element);
+    }
+    return result;
+}
+toSetAsync$1.toSetAsync = toSetAsync;
+
+differenceAsync$1.differenceAsync = void 0;
+const filter_async_1$1 = filterAsync$1;
+const to_set_async_1$1 = toSetAsync$1;
+async function* differenceAsync(left, right) {
+    const rightSet = await (0, to_set_async_1$1.toSetAsync)(right);
+    yield* (0, filter_async_1$1.filterAsync)(left, async (x) => !rightSet.has(await x));
+}
+differenceAsync$1.differenceAsync = differenceAsync;
+
+var difference$1 = {};
+
+var filter$3 = {};
+
+filter$3.filter = void 0;
+function* filter$2(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+filter$3.filter = filter$2;
+
+var toSet$1 = {};
+
+toSet$1.toSet = void 0;
+function toSet(iterable) {
+    return new Set(iterable);
+}
+toSet$1.toSet = toSet;
+
+difference$1.difference = void 0;
+const filter_1$6 = filter$3;
+const to_set_1$1 = toSet$1;
+function difference(left, right) {
+    const rightSet = (0, to_set_1$1.toSet)(right);
+    return (0, filter_1$6.filter)(left, x => !rightSet.has(x));
+}
+difference$1.difference = difference;
+
 var dropAsync$1 = {};
 
 var utils = {};
@@ -6393,17 +6478,30 @@ dropAsync$1.dropAsync = dropAsync;
 
 var dropRightAsync$1 = {};
 
+var toArrayAsync$1 = {};
+
+toArrayAsync$1.toArrayAsync = void 0;
+async function toArrayAsync(iterable) {
+    const result = [];
+    for await (const element of iterable) {
+        result.push(element);
+    }
+    return result;
+}
+toArrayAsync$1.toArrayAsync = toArrayAsync;
+
 dropRightAsync$1.dropRightAsync = void 0;
 const go_1$a = es2018$4;
 const utils_1$2 = utils;
 const errors_1$f = es2018$b;
+const to_array_async_1 = toArrayAsync$1;
 function dropRightAsync(iterable, count) {
     (0, errors_1$f.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$f.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
         return (0, utils_1$2.copyAsyncIterable)(iterable);
     return (0, go_1$a.go)(async function* () {
-        const arr = await toArrayAsync$2(iterable);
+        const arr = await (0, to_array_async_1.toArrayAsync)(iterable);
         const result = arr.slice(0, -count);
         for (const value of result) {
             yield value;
@@ -6411,13 +6509,6 @@ function dropRightAsync(iterable, count) {
     });
 }
 dropRightAsync$1.dropRightAsync = dropRightAsync;
-async function toArrayAsync$2(iterable) {
-    const result = [];
-    for await (const element of iterable) {
-        result.push(element);
-    }
-    return result;
-}
 
 var dropRight$1 = {};
 
@@ -6440,9 +6531,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$g = es2018$1;
+const types_1$f = es2018$1;
 function dropUntilAsync(iterable, predicate) {
-    if ((0, types_1$g.isAsyncIterable)(iterable)) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable, predicate);
     }
     else {
@@ -6554,49 +6645,6 @@ function drop(iterable, count) {
 }
 drop$1.drop = drop;
 
-var filterAsync$1 = {};
-
-filterAsync$1.filterAsync = void 0;
-const types_1$f = es2018$1;
-function filterAsync(iterable, predicate) {
-    if ((0, types_1$f.isAsyncIterable)(iterable)) {
-        return filterAsyncIterable(iterable, predicate);
-    }
-    else {
-        return filterIterable(iterable, predicate);
-    }
-}
-filterAsync$1.filterAsync = filterAsync;
-async function* filterAsyncIterable(iterable, predicate) {
-    let index = 0;
-    for await (const element of iterable) {
-        if (await predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-async function* filterIterable(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (await predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-
-var filter$3 = {};
-
-filter$3.filter = void 0;
-function* filter$2(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-filter$3.filter = filter$2;
-
 var flattenAsync$1 = {};
 
 var flattenDeepAsync$1 = {};
@@ -6702,6 +6750,28 @@ function flatten(iterable) {
 }
 flatten$1.flatten = flatten;
 
+var intersectionAsync$1 = {};
+
+intersectionAsync$1.intersectionAsync = void 0;
+const filter_async_1 = filterAsync$1;
+const to_set_async_1 = toSetAsync$1;
+async function* intersectionAsync(left, right) {
+    const rightSet = await (0, to_set_async_1.toSetAsync)(right);
+    yield* (0, filter_async_1.filterAsync)(left, async (x) => rightSet.has(await x));
+}
+intersectionAsync$1.intersectionAsync = intersectionAsync;
+
+var intersection$1 = {};
+
+intersection$1.intersection = void 0;
+const filter_1$5 = filter$3;
+const to_set_1 = toSet$1;
+function intersection(left, right) {
+    const rightSet = (0, to_set_1.toSet)(right);
+    return (0, filter_1$5.filter)(left, x => rightSet.has(x));
+}
+intersection$1.intersection = intersection;
+
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
@@ -7154,7 +7224,7 @@ var toAsyncIterable$1 = {};
 toAsyncIterable$1.toAsyncIterable = void 0;
 async function* toAsyncIterable(iterable) {
     for (const value of iterable) {
-        yield value;
+        yield await value;
     }
 }
 toAsyncIterable$1.toAsyncIterable = toAsyncIterable;
@@ -7299,7 +7369,7 @@ async function* zipWithSize$1(...iterables) {
                     dones[i] = true;
                     return;
                 }
-                result[i] = temp.value;
+                result[i] = await temp.value;
             }
             yield result;
         }
@@ -7368,6 +7438,8 @@ function* zipWithSize(...iterables) {
 	__exportStar(chunk$1, exports);
 	__exportStar(concatAsync$1, exports);
 	__exportStar(concat$5, exports);
+	__exportStar(differenceAsync$1, exports);
+	__exportStar(difference$1, exports);
 	__exportStar(dropAsync$1, exports);
 	__exportStar(dropRightAsync$1, exports);
 	__exportStar(dropRight$1, exports);
@@ -7382,6 +7454,8 @@ function* zipWithSize(...iterables) {
 	__exportStar(flattenDeepAsync$1, exports);
 	__exportStar(flattenDeep$1, exports);
 	__exportStar(flatten$1, exports);
+	__exportStar(intersectionAsync$1, exports);
+	__exportStar(intersection$1, exports);
 	__exportStar(mapAsync$1, exports);
 	__exportStar(map$3, exports);
 	__exportStar(repeatAsync$1, exports);
@@ -7410,9 +7484,9 @@ function* zipWithSize(...iterables) {
 	__exportStar(zipAsync$1, exports);
 	__exportStar(zip$5, exports);
 	
-} (middleware));
+} (intermediate));
 
-var output = {};
+var terminal = {};
 
 var consume$1 = {};
 
@@ -7422,6 +7496,14 @@ function consume(iterable, consumer) {
 }
 consume$1.consume = consume;
 
+var consumeAsync$1 = {};
+
+consumeAsync$1.consumeAsync = void 0;
+async function consumeAsync(iterable, consumer) {
+    return await consumer(iterable);
+}
+consumeAsync$1.consumeAsync = consumeAsync;
+
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
@@ -7600,38 +7682,6 @@ function includes(iterable, value) {
 }
 includes$1.includes = includes;
 
-var matchAsync$1 = {};
-
-matchAsync$1.matchAsync = void 0;
-async function matchAsync(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for await (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
-            return true;
-    }
-    return false;
-}
-matchAsync$1.matchAsync = matchAsync;
-
-var match$1 = {};
-
-match$1.match = void 0;
-function match(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
-            return true;
-    }
-    return false;
-}
-match$1.match = match;
-
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
@@ -7865,54 +7915,14 @@ function last$3(iterable) {
 }
 last$4.last = last$3;
 
-var toArrayAsync$1 = {};
-
-toArrayAsync$1.toArrayAsync = void 0;
-const consume_1$3 = consume$1;
-function toArrayAsync(iterable) {
-    return (0, consume_1$3.consume)(iterable, async (iterable) => {
-        const result = [];
-        for await (const element of iterable) {
-            result.push(element);
-        }
-        return result;
-    });
-}
-toArrayAsync$1.toArrayAsync = toArrayAsync;
-
 var toArray$3 = {};
 
 toArray$3.toArray = void 0;
-const consume_1$2 = consume$1;
 function toArray$2(iterable) {
-    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
+    return Array.from(iterable);
 }
 toArray$3.toArray = toArray$2;
 
-var toSetAsync$1 = {};
-
-toSetAsync$1.toSetAsync = void 0;
-const consume_1$1 = consume$1;
-function toSetAsync(iterable) {
-    return (0, consume_1$1.consume)(iterable, async (iterable) => {
-        const result = new Set();
-        for await (const element of iterable) {
-            result.add(element);
-        }
-        return result;
-    });
-}
-toSetAsync$1.toSetAsync = toSetAsync;
-
-var toSet$1 = {};
-
-toSet$1.toSet = void 0;
-const consume_1 = consume$1;
-function toSet(iterable) {
-    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
-}
-toSet$1.toSet = toSet;
-
 var count$3 = {};
 
 count$3.count = void 0;
@@ -7986,6 +7996,7 @@ groupByAsync$1.groupByAsync = groupByAsync;
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};__exportStar(consume$1, exports);
+	__exportStar(consumeAsync$1, exports);
 	__exportStar(eachAsync$1, exports);
 	__exportStar(each$1, exports);
 	__exportStar(everyAsync$1, exports);
@@ -7996,8 +8007,6 @@ groupByAsync$1.groupByAsync = groupByAsync;
 	__exportStar(first$3, exports);
 	__exportStar(includesAsync$1, exports);
 	__exportStar(includes$1, exports);
-	__exportStar(matchAsync$1, exports);
-	__exportStar(match$1, exports);
 	__exportStar(reduceAsync$1, exports);
 	__exportStar(reduce$3, exports);
 	__exportStar(someAsync$1, exports);
@@ -8013,7 +8022,7 @@ groupByAsync$1.groupByAsync = groupByAsync;
 	__exportStar(groupBy$3, exports);
 	__exportStar(groupByAsync$1, exports);
 	
-} (output));
+} (terminal));
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -8029,8 +8038,8 @@ groupByAsync$1.groupByAsync = groupByAsync;
 	}));
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(middleware, exports);
-	__exportStar(output, exports);
+	};__exportStar(intermediate, exports);
+	__exportStar(terminal, exports);
 	
 } (es2018$5));