@tamagui/use-async 1.128.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tamagui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/dist/cjs/errors.cjs

@@ -0,0 +1,30 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  AbortError: () => AbortError
+});
+module.exports = __toCommonJS(errors_exports);
+class AbortError extends Error {
+  constructor(message = "") {
+    super(message), this.name = "AbortError";
+  }
+}

package/dist/cjs/errors.js

@@ -0,0 +1,25 @@
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  AbortError: () => AbortError
+});
+module.exports = __toCommonJS(errors_exports);
+class AbortError extends Error {
+  constructor(message = "") {
+    super(message), this.name = "AbortError";
+  }
+}
+//# sourceMappingURL=errors.js.map

package/dist/cjs/errors.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAO,MAAM,mBAAmB,MAAM;AAAA,EACpC,YAAY,UAAU,IAAI;AACxB,UAAM,OAAO,GACb,KAAK,OAAO;AAAA,EACd;AACF;",
+  "names": []
+}

package/dist/cjs/errors.native.js

@@ -0,0 +1,124 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  AbortError: () => AbortError
+});
+module.exports = __toCommonJS(errors_exports);
+function _assert_this_initialized(self) {
+  if (self === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return self;
+}
+function _call_super(_this, derived, args) {
+  return derived = _get_prototype_of(derived), _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+  return _is_native_reflect_construct() ? _construct = Reflect.construct : _construct = function(Parent2, args2, Class2) {
+    var a = [
+      null
+    ];
+    a.push.apply(a, args2);
+    var Constructor = Function.bind.apply(Parent2, a), instance = new Constructor();
+    return Class2 && _set_prototype_of(instance, Class2.prototype), instance;
+  }, _construct.apply(null, arguments);
+}
+function _get_prototype_of(o) {
+  return _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  }, _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass != "function" && superClass !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: !0,
+      configurable: !0
+    }
+  }), superClass && _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+  return call && (_type_of(call) === "object" || typeof call == "function") ? call : _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  return _set_prototype_of = Object.setPrototypeOf || function(o2, p2) {
+    return o2.__proto__ = p2, o2;
+  }, _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;
+  return _wrap_native_super = function(Class2) {
+    if (Class2 === null || !_is_native_function(Class2)) return Class2;
+    if (typeof Class2 != "function")
+      throw new TypeError("Super expression must either be null or a function");
+    if (typeof _cache < "u") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _set_prototype_of(Wrapper, Class2);
+  }, _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (_is_native_reflect_construct = function() {
+    return !!result;
+  })();
+}
+var AbortError = /* @__PURE__ */ function(Error1) {
+  "use strict";
+  _inherits(AbortError2, Error1);
+  function AbortError2() {
+    var message = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : "";
+    _class_call_check(this, AbortError2);
+    var _this;
+    return _this = _call_super(this, AbortError2, [
+      message
+    ]), _this.name = "AbortError", _this;
+  }
+  return AbortError2;
+}(_wrap_native_super(Error));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbortError
+});
+//# sourceMappingURL=errors.js.map

package/dist/cjs/errors.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/errors.ts"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAO,IAAMA,aAAN,yBAAA,QAAA;;YAAMA,aAAAA,MAAAA;WAAAA,cAAAA;QACCC,UAAAA,UAAAA,SAAAA,KAAAA,UAAAA,CAAAA,MAAAA,SAAAA,UAAAA,CAAAA,IAAU;4BADXD,WAAAA;;mBAET,YAAA,MAFSA,aAAAA;MAEHC;QACN,MAAKC,OAAO;;SAHHF;qBAAmBG,KAAAA,CAAAA;",
+  "names": ["AbortError", "message", "name", "Error"]
+}

package/dist/cjs/idle.cjs

@@ -0,0 +1,38 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var idle_exports = {};
+__export(idle_exports, {
+  fullyIdle: () => fullyIdle,
+  idle: () => idle
+});
+module.exports = __toCommonJS(idle_exports);
+var import_errors = require("./errors.cjs");
+const idleCb = typeof requestIdleCallback > "u" ? cb => setTimeout(cb, 1) : requestIdleCallback,
+  idle = async signal => {
+    if (await new Promise(res => idleCb(res)), signal?.aborted) throw new import_errors.AbortError();
+  },
+  fullyIdle = async signal => {
+    for (;;) {
+      const startTime = Date.now();
+      if (await idle(signal), Date.now() - startTime < 15) break;
+      if (signal?.aborted) throw new import_errors.AbortError();
+    }
+  };

package/dist/cjs/idle.js

@@ -0,0 +1,34 @@
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var idle_exports = {};
+__export(idle_exports, {
+  fullyIdle: () => fullyIdle,
+  idle: () => idle
+});
+module.exports = __toCommonJS(idle_exports);
+var import_errors = require("./errors");
+const idleCb = typeof requestIdleCallback > "u" ? (cb) => setTimeout(cb, 1) : requestIdleCallback, idle = async (signal) => {
+  if (await new Promise((res) => idleCb(res)), signal?.aborted)
+    throw new import_errors.AbortError();
+}, fullyIdle = async (signal) => {
+  for (; ; ) {
+    const startTime = Date.now();
+    if (await idle(signal), Date.now() - startTime < 15)
+      break;
+    if (signal?.aborted)
+      throw new import_errors.AbortError();
+  }
+};
+//# sourceMappingURL=idle.js.map

package/dist/cjs/idle.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/idle.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA2B;AAE3B,MAAM,SACJ,OAAO,sBAAwB,MAC3B,CAAC,OAAiB,WAAW,IAAI,CAAC,IAClC,qBAEO,OAAO,OAAO,WAAwC;AAEjE,MADA,MAAM,IAAI,QAAQ,CAAC,QAAQ,OAAO,GAAG,CAAC,GAClC,QAAQ;AACV,UAAM,IAAI,yBAAW;AAEzB,GAEa,YAAY,OAAO,WAAwC;AACtE,aAAa;AACX,UAAM,YAAY,KAAK,IAAI;AAM3B,QALA,MAAM,KAAK,MAAM,GACD,KAAK,IAAI,IACE,YAGZ;AACb;AAIF,QAAI,QAAQ;AACV,YAAM,IAAI,yBAAW;AAAA,EAEzB;AACF;",
+  "names": []
+}

package/dist/cjs/idle.native.js

@@ -0,0 +1,45 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var idle_exports = {};
+__export(idle_exports, {
+  fullyIdle: () => fullyIdle,
+  idle: () => idle
+});
+module.exports = __toCommonJS(idle_exports);
+var import_errors = require("./errors"), idleCb = typeof requestIdleCallback > "u" ? function(cb) {
+  return setTimeout(cb, 1);
+} : requestIdleCallback, idle = async function(signal) {
+  if (await new Promise(function(res) {
+    return idleCb(res);
+  }), signal != null && signal.aborted)
+    throw new import_errors.AbortError();
+}, fullyIdle = async function(signal) {
+  for (; ; ) {
+    var startTime = Date.now();
+    await idle(signal);
+    var endTime = Date.now(), duration = endTime - startTime;
+    if (duration < 15)
+      break;
+    if (signal != null && signal.aborted)
+      throw new import_errors.AbortError();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fullyIdle,
+  idle
+});
+//# sourceMappingURL=idle.js.map

package/dist/cjs/idle.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/idle.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;;oBAA2B,qBAErBA,SACJ,OAAOC,sBAAwB,MAC3B,SAACC,IAAAA;SAAiBC,WAAWD,IAAI,CAAA;IACjCD,qBAEOG,OAAO,eAAOC,QAAAA;AAEzB,MADA,MAAM,IAAIC,QAAQ,SAACC,KAAAA;WAAQP,OAAOO,GAAAA;MAC9BF,UAAAA,QAAAA,OAAQG;AACV,UAAM,IAAIC,yBAAAA;AAEd,GAEaC,YAAY,eAAOL,QAAAA;AAC9B,aAAa;AACX,QAAMM,YAAYC,KAAKC,IAAG;AAC1B,UAAMT,KAAKC,MAAAA;AACX,QAAMS,UAAUF,KAAKC,IAAG,GAClBE,WAAWD,UAAUH;AAG3B,QAAII,WAAW;AACb;AAIF,QAAIV,UAAAA,QAAAA,OAAQG;AACV,YAAM,IAAIC,yBAAAA;EAEd;AACF;",
+  "names": ["idleCb", "requestIdleCallback", "cb", "setTimeout", "idle", "signal", "Promise", "res", "aborted", "AbortError", "fullyIdle", "startTime", "Date", "now", "endTime", "duration"]
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,21 @@
+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)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  },
+  __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./useAsyncEffect.cjs"), module.exports);
+__reExport(index_exports, require("./sleep.cjs"), module.exports);
+__reExport(index_exports, require("./idle.cjs"), module.exports);
+__reExport(index_exports, require("./errors.cjs"), module.exports);

package/dist/cjs/index.js

@@ -0,0 +1,18 @@
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./useAsyncEffect"), module.exports);
+__reExport(index_exports, require("./sleep"), module.exports);
+__reExport(index_exports, require("./idle"), module.exports);
+__reExport(index_exports, require("./errors"), module.exports);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "mappings": ";;;;;;;;;;;AAAA;AAAA;AAAA,0BAAc,6BAAd;AACA,0BAAc,oBADd;AAEA,0BAAc,mBAFd;AAGA,0BAAc,qBAHd;",
+  "names": []
+}

package/dist/cjs/index.native.js

@@ -0,0 +1,26 @@
+"use strict";
+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))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+}, __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./useAsyncEffect"), module.exports);
+__reExport(index_exports, require("./sleep"), module.exports);
+__reExport(index_exports, require("./idle"), module.exports);
+__reExport(index_exports, require("./errors"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./useAsyncEffect"),
+  ...require("./sleep"),
+  ...require("./idle"),
+  ...require("./errors")
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "mappings": ";;;;;;;;;;;;AAAA;;0BAAc,6BAAd;AACA,0BAAc,oBADd;AAEA,0BAAc,mBAFd;AAGA,0BAAc,qBAHd;",
+  "names": []
+}

package/dist/cjs/sleep.cjs

@@ -0,0 +1,29 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+var import_errors = require("./errors.cjs");
+const sleep = async (ms, signal) => {
+  if (await new Promise(res => setTimeout(res, ms)), signal?.aborted) throw new import_errors.AbortError();
+};

package/dist/cjs/sleep.js

@@ -0,0 +1,25 @@
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+var import_errors = require("./errors");
+const sleep = async (ms, signal) => {
+  if (await new Promise((res) => setTimeout(res, ms)), signal?.aborted)
+    throw new import_errors.AbortError();
+};
+//# sourceMappingURL=sleep.js.map

package/dist/cjs/sleep.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/sleep.ts"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA2B;AAEpB,MAAM,QAAQ,OAAO,IAAY,WAAwC;AAE9E,MADA,MAAM,IAAI,QAAQ,CAAC,QAAQ,WAAW,KAAK,EAAE,CAAC,GAC1C,QAAQ;AACV,UAAM,IAAI,yBAAW;AAEzB;",
+  "names": []
+}

package/dist/cjs/sleep.native.js

@@ -0,0 +1,31 @@
+"use strict";
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+var import_errors = require("./errors"), sleep = async function(ms, signal) {
+  if (await new Promise(function(res) {
+    return setTimeout(res, ms);
+  }), signal != null && signal.aborted)
+    throw new import_errors.AbortError();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sleep
+});
+//# sourceMappingURL=sleep.js.map

package/dist/cjs/sleep.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/sleep.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;oBAA2B,qBAEdA,QAAQ,eAAOC,IAAYC,QAAAA;AAEtC,MADA,MAAM,IAAIC,QAAQ,SAACC,KAAAA;WAAQC,WAAWD,KAAKH,EAAAA;MACvCC,UAAAA,QAAAA,OAAQI;AACV,UAAM,IAAIC,yBAAAA;AAEd;",
+  "names": ["sleep", "ms", "signal", "Promise", "res", "setTimeout", "aborted", "AbortError"]
+}

package/dist/cjs/useAsyncEffect.cjs

@@ -0,0 +1,61 @@
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var useAsyncEffect_exports = {};
+__export(useAsyncEffect_exports, {
+  useAsyncEffect: () => useAsyncEffect,
+  useAsyncEffectOfType: () => useAsyncEffectOfType,
+  useAsyncLayoutEffect: () => useAsyncLayoutEffect
+});
+module.exports = __toCommonJS(useAsyncEffect_exports);
+var import_react = require("react"),
+  import_errors = require("./errors.cjs");
+const DEBUG_LEVEL = 0;
+function useAsyncEffect(cb, deps = []) {
+  useAsyncEffectOfType(import_react.useEffect, cb, deps);
+}
+function useAsyncLayoutEffect(cb, deps = []) {
+  useAsyncEffectOfType(import_react.useLayoutEffect, cb, deps);
+}
+function useAsyncEffectOfType(type, cb, deps = []) {
+  type(() => {
+    const controller = new AbortController(),
+      signal = controller.signal;
+    try {
+      const value = cb(signal, ...deps);
+      Promise.resolve(value).then(async res => {
+        if (res && typeof res == "function") {
+          if (signal.aborted) return res();
+          signal.addEventListener("abort", res);
+        }
+      }).catch(handleError);
+    } catch (error) {
+      handleError(error);
+    }
+    function handleError(error) {
+      if (error instanceof import_errors.AbortError) return DEBUG_LEVEL > 2 && console.info(`\u{1F41B} useAsyncEffect aborted: ${error.message}`), null;
+      if (typeof error == "object" && error.name === "AbortError") return null;
+      throw error;
+    }
+    return () => {
+      signal.aborted || controller.abort();
+    };
+  }, deps);
+}