@wener/utils 1.1.0 → 1.1.1

package/README.md

@@ -1,8 +1,5 @@
 # Daily use utils
 
-* [Document](https://apis.wener.me/docs/@wener/utils/index.html)
-
-
 <!-- LINK:BEGIN -->
 
 # Links
@@ -15,6 +12,11 @@
     * APIs playground with docs & stories
     * Github [wenerme/apis](https://github.com/wenerme/apis)
 * Library
+  * [@wener/reaction](https://www.npmjs.com/package/@wener/reaction) - ![VERSION](https://img.shields.io/npm/v/@wener/reaction) - ![LICENSE](https://img.shields.io/npm/l/@wener/reaction)
+    * React hooks, render, logical components
+    * helpful typing
+    * some external minimal helpful utils
+      * reduce packages
   * [@wener/utils](https://www.npmjs.com/package/@wener/utils) - ![VERSION](https://img.shields.io/npm/v/@wener/utils) - ![LICENSE](https://img.shields.io/npm/l/@wener/utils)
     * utils for daily use
     * [Document](https://apis.wener.me/docs/@wener/utils/)

package/lib/cjs/arrays/MaybeArray.js

@@ -1,35 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayOfMaybeArray = exports.lastOfMaybeArray = exports.firstOfMaybeArray = exports.objectOfMaybeArray = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MaybeArray_exports = {};
+__export(MaybeArray_exports, {
+  arrayOfMaybeArray: () => arrayOfMaybeArray,
+  firstOfMaybeArray: () => firstOfMaybeArray,
+  lastOfMaybeArray: () => lastOfMaybeArray,
+  objectOfMaybeArray: () => objectOfMaybeArray
+});
+module.exports = __toCommonJS(MaybeArray_exports);
 function objectOfMaybeArray(o, keys = null, picker = firstOfMaybeArray) {
-    if (keys === null) {
-        return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
-    }
-    return Object.fromEntries(keys.map((v) => [v, picker(v)]));
+  if (keys === null) {
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
+  }
+  return Object.fromEntries(keys.map((v) => [v, picker(v)]));
 }
-exports.objectOfMaybeArray = objectOfMaybeArray;
 function firstOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v[0];
-    }
-    return v;
+  if (Array.isArray(v)) {
+    return v[0];
+  }
+  return v;
 }
-exports.firstOfMaybeArray = firstOfMaybeArray;
 function lastOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v[v.length - 1];
-    }
-    return v;
+  if (Array.isArray(v)) {
+    return v[v.length - 1];
+  }
+  return v;
 }
-exports.lastOfMaybeArray = lastOfMaybeArray;
 function arrayOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v;
-    }
-    if (v === null || v === undefined) {
-        return [];
-    }
-    return [v];
+  if (Array.isArray(v)) {
+    return v;
+  }
+  if (v === null || v === void 0) {
+    return [];
+  }
+  return [v];
 }
-exports.arrayOfMaybeArray = arrayOfMaybeArray;
-//# sourceMappingURL=MaybeArray.js.map

package/lib/cjs/arrays/index.js

@@ -1,5 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./MaybeArray"), exports);
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arrays_exports = {};
+module.exports = __toCommonJS(arrays_exports);
+__reExport(arrays_exports, require("./MaybeArray"), module.exports);

package/lib/cjs/asyncs/AsyncInterval.js

@@ -1,18 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearAsyncInterval = exports.setAsyncInterval = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AsyncInterval_exports = {};
+__export(AsyncInterval_exports, {
+  clearAsyncInterval: () => clearAsyncInterval,
+  setAsyncInterval: () => setAsyncInterval
+});
+module.exports = __toCommonJS(AsyncInterval_exports);
 function setAsyncInterval(cb, interval, initial = interval) {
-    let id;
-    const handler = async () => {
-        await cb();
-        id = setTimeout(handler, interval);
-    };
-    id = setTimeout(handler, initial);
-    return () => id;
+  let id;
+  const handler = async () => {
+    await cb();
+    id = setTimeout(handler, interval);
+  };
+  id = setTimeout(handler, initial);
+  return () => id;
 }
-exports.setAsyncInterval = setAsyncInterval;
 function clearAsyncInterval(v) {
-    clearTimeout(v?.());
+  clearTimeout(v == null ? void 0 : v());
 }
-exports.clearAsyncInterval = clearAsyncInterval;
-//# sourceMappingURL=AsyncInterval.js.map

package/lib/cjs/asyncs/LazyPromise.js

@@ -1,26 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLazyPromise = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LazyPromise_exports = {};
+__export(LazyPromise_exports, {
+  createLazyPromise: () => createLazyPromise
+});
+module.exports = __toCommonJS(LazyPromise_exports);
 function createLazyPromise() {
-    const holder = {
-        resolve(_) {
-            throw new Error('pending resolve');
-        },
-        reject(_) {
-            throw new Error('pending reject');
-        },
-    };
-    return Object.assign(new Promise((resolve, reject) => {
-        holder.reject = reject;
-        holder.resolve = resolve;
-    }), {
-        resolve(v) {
-            holder.resolve(v);
-        },
-        reject(v) {
-            holder.resolve(v);
-        },
-    });
+  const holder = {
+    resolve(_) {
+      throw new Error("pending resolve");
+    },
+    reject(_) {
+      throw new Error("pending reject");
+    }
+  };
+  return Object.assign(new Promise((resolve, reject) => {
+    holder.reject = reject;
+    holder.resolve = resolve;
+  }), {
+    resolve(v) {
+      holder.resolve(v);
+    },
+    reject(v) {
+      holder.resolve(v);
+    }
+  });
 }
-exports.createLazyPromise = createLazyPromise;
-//# sourceMappingURL=LazyPromise.js.map

package/lib/cjs/asyncs/MaybePromise.js

@@ -1,3 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=MaybePromise.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MaybePromise_exports = {};
+module.exports = __toCommonJS(MaybePromise_exports);

package/lib/cjs/asyncs/generatorOfStream.js

@@ -1,18 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatorOfStream = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generatorOfStream_exports = {};
+__export(generatorOfStream_exports, {
+  generatorOfStream: () => generatorOfStream
+});
+module.exports = __toCommonJS(generatorOfStream_exports);
 function* generatorOfStream(stream) {
-    let done = false;
-    stream.on('end', () => {
-        done = true;
+  let done = false;
+  stream.on("end", () => {
+    done = true;
+  });
+  while (!done) {
+    yield new Promise((resolve, reject) => {
+      stream.once("data", resolve);
+      stream.once("end", resolve);
+      stream.once("error", reject);
     });
-    while (!done) {
-        yield new Promise((resolve, reject) => {
-            stream.once('data', resolve);
-            stream.once('end', resolve);
-            stream.once('error', reject);
-        });
-    }
+  }
 }
-exports.generatorOfStream = generatorOfStream;
-//# sourceMappingURL=generatorOfStream.js.map

package/lib/cjs/asyncs/index.js

@@ -1,11 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./LazyPromise"), exports);
-tslib_1.__exportStar(require("./AsyncInterval"), exports);
-tslib_1.__exportStar(require("./MaybePromise"), exports);
-tslib_1.__exportStar(require("./sleep"), exports);
-tslib_1.__exportStar(require("./timeout"), exports);
-tslib_1.__exportStar(require("./isPromise"), exports);
-tslib_1.__exportStar(require("./promiseOfCallback"), exports);
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asyncs_exports = {};
+module.exports = __toCommonJS(asyncs_exports);
+__reExport(asyncs_exports, require("./LazyPromise"), module.exports);
+__reExport(asyncs_exports, require("./AsyncInterval"), module.exports);
+__reExport(asyncs_exports, require("./MaybePromise"), module.exports);
+__reExport(asyncs_exports, require("./sleep"), module.exports);
+__reExport(asyncs_exports, require("./timeout"), module.exports);
+__reExport(asyncs_exports, require("./isPromise"), module.exports);
+__reExport(asyncs_exports, require("./promiseOfCallback"), module.exports);

package/lib/cjs/asyncs/isPromise.js

@@ -1,8 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromise = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isPromise_exports = {};
+__export(isPromise_exports, {
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(isPromise_exports);
 function isPromise(v) {
-    return v && (v instanceof Promise || (v.then && v.catch));
+  return v && (v instanceof Promise || v.then && v.catch);
 }
-exports.isPromise = isPromise;
-//# sourceMappingURL=isPromise.js.map

package/lib/cjs/asyncs/promiseOfCallback.js

@@ -1,22 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promiseOfCallback = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var promiseOfCallback_exports = {};
+__export(promiseOfCallback_exports, {
+  promiseOfCallback: () => promiseOfCallback
+});
+module.exports = __toCommonJS(promiseOfCallback_exports);
 function promiseOfCallback(fun) {
-    return new Promise((resolve, reject) => {
-        try {
-            fun((e, v) => {
-                if (e) {
-                    reject(e);
-                }
-                else {
-                    resolve(v);
-                }
-            });
+  return new Promise((resolve, reject) => {
+    try {
+      fun((e, v) => {
+        if (e) {
+          reject(e);
+        } else {
+          resolve(v);
         }
-        catch (e) {
-            reject(e);
-        }
-    });
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
 }
-exports.promiseOfCallback = promiseOfCallback;
-//# sourceMappingURL=promiseOfCallback.js.map

package/lib/cjs/asyncs/sleep.js

@@ -1,6 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-exports.sleep = sleep;
-//# sourceMappingURL=sleep.js.map

package/lib/cjs/asyncs/timeout.js

@@ -1,27 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeoutError = exports.timeout = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_exports = {};
+__export(timeout_exports, {
+  TimeoutError: () => TimeoutError,
+  timeout: () => timeout
+});
+module.exports = __toCommonJS(timeout_exports);
 function timeout(v, ms) {
-    const error = new TimeoutError();
-    let timeout;
-    return Promise.race([
-        v,
-        new Promise((_, reject) => {
-            timeout = setTimeout(() => reject(error), ms);
-        }),
-    ]).then((v) => {
-        clearTimeout(timeout);
-        return v;
-    }, (e) => {
-        clearTimeout(timeout);
-        throw e;
-    });
+  const error = new TimeoutError();
+  let timeout2;
+  return Promise.race([
+    v,
+    new Promise((_, reject) => {
+      timeout2 = setTimeout(() => reject(error), ms);
+    })
+  ]).then((v2) => {
+    clearTimeout(timeout2);
+    return v2;
+  }, (e) => {
+    clearTimeout(timeout2);
+    throw e;
+  });
 }
-exports.timeout = timeout;
 class TimeoutError extends Error {
-    constructor() {
-        super('TimeoutError');
-    }
+  constructor() {
+    super("TimeoutError");
+  }
 }
-exports.TimeoutError = TimeoutError;
-//# sourceMappingURL=timeout.js.map