@aiszlab/relax 1.5.4 → 1.5.6

package/dist/dom/clipboard.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var _regeneratorRuntime = require('@babel/runtime/helpers/regeneratorRuntime');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+
+var clipboard = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(value) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return navigator.clipboard.writeText(value);
+        case 2:
+          return _context.abrupt("return", _context.sent);
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function clipboard(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+exports.clipboard = clipboard;

package/dist/dom/clipboard.mjs

@@ -0,0 +1,24 @@
+import _regeneratorRuntime from '@babel/runtime/helpers/regeneratorRuntime';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+
+var clipboard = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(value) {
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return navigator.clipboard.writeText(value);
+        case 2:
+          return _context.abrupt("return", _context.sent);
+        case 3:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return function clipboard(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+export { clipboard };

package/dist/dom/index.cjs

@@ -2,8 +2,10 @@
 
 var scrollTo = require('./scroll-to.cjs');
 var contains = require('./contains.cjs');
+var clipboard = require('./clipboard.cjs');
 
 
 
 exports.scrollTo = scrollTo.scrollTo;
 exports.contains = contains.contains;
+exports.clipboard = clipboard.clipboard;

package/dist/dom/index.d.ts

@@ -1,4 +1,6 @@
 import { scrollTo, type Orientation } from "./scroll-to";
 import { contains, type Containable } from "./contains";
+import { clipboard } from "./clipboard";
+export { clipboard };
 export { scrollTo, contains };
 export type { Containable, Orientation };

package/dist/dom/index.mjs

@@ -1,2 +1,3 @@
 export { scrollTo } from './scroll-to.mjs';
 export { contains } from './contains.mjs';
+export { clipboard } from './clipboard.mjs';

package/dist/fetch-event-source/fetch.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+var _regeneratorRuntime = require('@babel/runtime/helpers/regeneratorRuntime');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var parse = require('./parse.cjs');
+
+var _excluded = ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden"];
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1000;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _ref) {
+  var inputSignal = _ref.signal,
+    inputHeaders = _ref.headers,
+    inputOnOpen = _ref.onopen,
+    onmessage = _ref.onmessage,
+    onclose = _ref.onclose,
+    onerror = _ref.onerror,
+    openWhenHidden = _ref.openWhenHidden,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return new Promise(function (resolve, reject) {
+    // make a copy of the input headers since we may modify it below:
+    var headers = _objectSpread({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    var curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort(); // close existing request on every visibility change
+      if (!document.hidden) {
+        create(); // page is now visible again, recreate request.
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    var retryInterval = DefaultRetryInterval;
+    var retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    // if the incoming signal aborts, dispose resources and resolve:
+    inputSignal === null || inputSignal === void 0 || inputSignal.addEventListener("abort", function () {
+      dispose();
+      resolve(); // don't waste time constructing/logging errors
+    });
+    var onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    function create() {
+      return _create.apply(this, arguments);
+    }
+    function _create() {
+      _create = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var response, _onerror, interval;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              curRequestController = new AbortController();
+              _context.prev = 1;
+              _context.next = 4;
+              return fetch(input, _objectSpread(_objectSpread({}, rest), {}, {
+                headers: headers,
+                signal: curRequestController.signal
+              }));
+            case 4:
+              response = _context.sent;
+              _context.next = 7;
+              return onopen(response);
+            case 7:
+              _context.next = 9;
+              return parse.getBytes(response.body, parse.getLines(parse.getMessages(function (id) {
+                if (id) {
+                  // store the id and send it back on the next retry:
+                  headers[LastEventId] = id;
+                } else {
+                  // don't send the last-event-id header anymore:
+                  delete headers[LastEventId];
+                }
+              }, function (retry) {
+                retryInterval = retry;
+              }, onmessage)));
+            case 9:
+              onclose === null || onclose === void 0 || onclose();
+              dispose();
+              resolve();
+              _context.next = 17;
+              break;
+            case 14:
+              _context.prev = 14;
+              _context.t0 = _context["catch"](1);
+              if (!curRequestController.signal.aborted) {
+                // if we haven't aborted the request ourselves:
+                try {
+                  // check if we need to retry:
+                  interval = (_onerror = onerror === null || onerror === void 0 ? void 0 : onerror(_context.t0)) !== null && _onerror !== void 0 ? _onerror : retryInterval;
+                  window.clearTimeout(retryTimer);
+                  retryTimer = window.setTimeout(create, interval);
+                } catch (innerErr) {
+                  // we should not retry anymore:
+                  dispose();
+                  reject(innerErr);
+                }
+              }
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 14]]);
+      }));
+      return _create.apply(this, arguments);
+    }
+    create();
+  });
+}
+function defaultOnOpen(_x) {
+  return _defaultOnOpen.apply(this, arguments);
+}
+function _defaultOnOpen() {
+  _defaultOnOpen = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(response) {
+    var contentType;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          contentType = response.headers.get("content-type");
+          if (contentType !== null && contentType !== void 0 && contentType.startsWith(EventStreamContentType)) {
+            _context2.next = 3;
+            break;
+          }
+          throw new Error("Expected content-type to be ".concat(EventStreamContentType, ", Actual: ").concat(contentType));
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _defaultOnOpen.apply(this, arguments);
+}
+
+exports.EventStreamContentType = EventStreamContentType;
+exports.fetchEventSource = fetchEventSource;

package/dist/fetch-event-source/fetch.d.ts

@@ -0,0 +1,42 @@
+import { EventSourceMessage } from "./parse";
+export declare const EventStreamContentType = "text/event-stream";
+export interface FetchEventSourceInit extends RequestInit {
+    /**
+     * The request headers. FetchEventSource only supports the Record<string,string> format.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Called when a response is received. Use this to validate that the response
+     * actually matches what you expect (and throw if it doesn't.) If not provided,
+     * will default to a basic validation to ensure the content-type is text/event-stream.
+     */
+    onopen?: (response: Response) => Promise<void>;
+    /**
+     * Called when a message is received. NOTE: Unlike the default browser
+     * EventSource.onmessage, this callback is called for _all_ events,
+     * even ones with a custom `event` field.
+     */
+    onmessage?: (ev: EventSourceMessage) => void;
+    /**
+     * Called when a response finishes. If you don't expect the server to kill
+     * the connection, you can throw an exception here and retry using onerror.
+     */
+    onclose?: () => void;
+    /**
+     * Called when there is any error making the request / processing messages /
+     * handling callbacks etc. Use this to control the retry strategy: if the
+     * error is fatal, rethrow the error inside the callback to stop the entire
+     * operation. Otherwise, you can return an interval (in milliseconds) after
+     * which the request will automatically retry (with the last-event-id).
+     * If this callback is not specified, or it returns undefined, fetchEventSource
+     * will treat every error as retriable and will try again after 1 second.
+     */
+    onerror?: (err: any) => number | null | undefined | void;
+    /**
+     * If true, will keep the request open even if the document is hidden.
+     * By default, fetchEventSource will close the request and reopen it
+     * automatically when the document becomes visible again.
+     */
+    openWhenHidden?: boolean;
+}
+export declare function fetchEventSource(input: RequestInfo, { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, ...rest }: FetchEventSourceInit): Promise<void>;

package/dist/fetch-event-source/fetch.mjs

@@ -0,0 +1,139 @@
+import _regeneratorRuntime from '@babel/runtime/helpers/regeneratorRuntime';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import { getBytes, getLines, getMessages } from './parse.mjs';
+
+var _excluded = ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden"];
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1000;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _ref) {
+  var inputSignal = _ref.signal,
+    inputHeaders = _ref.headers,
+    inputOnOpen = _ref.onopen,
+    onmessage = _ref.onmessage,
+    onclose = _ref.onclose,
+    onerror = _ref.onerror,
+    openWhenHidden = _ref.openWhenHidden,
+    rest = _objectWithoutProperties(_ref, _excluded);
+  return new Promise(function (resolve, reject) {
+    // make a copy of the input headers since we may modify it below:
+    var headers = _objectSpread({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    var curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort(); // close existing request on every visibility change
+      if (!document.hidden) {
+        create(); // page is now visible again, recreate request.
+      }
+    }
+    if (!openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    var retryInterval = DefaultRetryInterval;
+    var retryTimer = 0;
+    function dispose() {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      window.clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    // if the incoming signal aborts, dispose resources and resolve:
+    inputSignal === null || inputSignal === void 0 || inputSignal.addEventListener("abort", function () {
+      dispose();
+      resolve(); // don't waste time constructing/logging errors
+    });
+    var onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    function create() {
+      return _create.apply(this, arguments);
+    }
+    function _create() {
+      _create = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var response, _onerror, interval;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              curRequestController = new AbortController();
+              _context.prev = 1;
+              _context.next = 4;
+              return fetch(input, _objectSpread(_objectSpread({}, rest), {}, {
+                headers: headers,
+                signal: curRequestController.signal
+              }));
+            case 4:
+              response = _context.sent;
+              _context.next = 7;
+              return onopen(response);
+            case 7:
+              _context.next = 9;
+              return getBytes(response.body, getLines(getMessages(function (id) {
+                if (id) {
+                  // store the id and send it back on the next retry:
+                  headers[LastEventId] = id;
+                } else {
+                  // don't send the last-event-id header anymore:
+                  delete headers[LastEventId];
+                }
+              }, function (retry) {
+                retryInterval = retry;
+              }, onmessage)));
+            case 9:
+              onclose === null || onclose === void 0 || onclose();
+              dispose();
+              resolve();
+              _context.next = 17;
+              break;
+            case 14:
+              _context.prev = 14;
+              _context.t0 = _context["catch"](1);
+              if (!curRequestController.signal.aborted) {
+                // if we haven't aborted the request ourselves:
+                try {
+                  // check if we need to retry:
+                  interval = (_onerror = onerror === null || onerror === void 0 ? void 0 : onerror(_context.t0)) !== null && _onerror !== void 0 ? _onerror : retryInterval;
+                  window.clearTimeout(retryTimer);
+                  retryTimer = window.setTimeout(create, interval);
+                } catch (innerErr) {
+                  // we should not retry anymore:
+                  dispose();
+                  reject(innerErr);
+                }
+              }
+            case 17:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, null, [[1, 14]]);
+      }));
+      return _create.apply(this, arguments);
+    }
+    create();
+  });
+}
+function defaultOnOpen(_x) {
+  return _defaultOnOpen.apply(this, arguments);
+}
+function _defaultOnOpen() {
+  _defaultOnOpen = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(response) {
+    var contentType;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          contentType = response.headers.get("content-type");
+          if (contentType !== null && contentType !== void 0 && contentType.startsWith(EventStreamContentType)) {
+            _context2.next = 3;
+            break;
+          }
+          throw new Error("Expected content-type to be ".concat(EventStreamContentType, ", Actual: ").concat(contentType));
+        case 3:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _defaultOnOpen.apply(this, arguments);
+}
+
+export { EventStreamContentType, fetchEventSource };

package/dist/fetch-event-source/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var fetch = require('./fetch.cjs');
+
+
+
+exports.fetchEventSource = fetch.fetchEventSource;

package/dist/fetch-event-source/index.d.ts

@@ -0,0 +1,2 @@
+import { fetchEventSource } from "./fetch";
+export { fetchEventSource };

package/dist/fetch-event-source/index.mjs

@@ -0,0 +1 @@
+export { fetchEventSource } from './fetch.mjs';

package/dist/fetch-event-source/parse.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var _regeneratorRuntime = require('@babel/runtime/helpers/regeneratorRuntime');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
+
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+function getBytes(_x, _x2) {
+  return _getBytes.apply(this, arguments);
+}
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+function _getBytes() {
+  _getBytes = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(stream, onChunk) {
+    var reader, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (stream) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          reader = stream.getReader();
+        case 3:
+          _context.next = 5;
+          return reader.read();
+        case 5:
+          if ((result = _context.sent).done) {
+            _context.next = 9;
+            break;
+          }
+          onChunk(result.value);
+          _context.next = 3;
+          break;
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getBytes.apply(this, arguments);
+}
+function getLines(onLine) {
+  var buffer;
+  var position; // current read position
+  var fieldLength; // length of the `field` portion of the line
+  var discardTrailingNewline = false;
+  // return a function that can process each incoming byte chunk:
+  return function onChunk(arr) {
+    if (buffer === undefined) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      // we're still parsing the old line. Append the new bytes into buffer:
+      buffer = concat(buffer, arr);
+    }
+    var bufLength = buffer.length;
+    var lineStart = 0; // index where the current line starts
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10 /* ControlChars.NewLine */) {
+          lineStart = ++position; // skip to next char
+        }
+        discardTrailingNewline = false;
+      }
+      // start looking forward till the end of line:
+      var lineEnd = -1; // index of the \r or \n char
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58 /* ControlChars.Colon */:
+            if (fieldLength === -1) {
+              // first colon in line
+              fieldLength = position - lineStart;
+            }
+            break;
+          // @ts-ignore:7029 \r case below should fallthrough to \n:
+          case 13 /* ControlChars.CarriageReturn */:
+            discardTrailingNewline = true;
+          case 10 /* ControlChars.NewLine */:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        // We reached the end of the buffer but the line hasn't ended.
+        // Wait for the next arr and then continue parsing:
+        break;
+      }
+      // we've reached the line end, send it out:
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position; // we're now on the next line
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = undefined; // we've finished reading it
+    } else if (lineStart !== 0) {
+      // Create a new view into buffer beginning at lineStart so we don't
+      // need to copy over the previous lines when we get the new arr:
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+function getMessages(onId, onRetry, onMessage) {
+  var message = newMessage();
+  var decoder = new TextDecoder();
+  // return a function that can process each incoming line buffer:
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      // empty line denotes end of message. Trigger the callback and start a new message:
+      onMessage === null || onMessage === void 0 || onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      // exclude comments and lines with no values
+      // line is of format "<field>:<value>" or "<field>: <value>"
+      // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+      var field = decoder.decode(line.subarray(0, fieldLength));
+      var valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
+      var value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          // if this message already has data, append the new value to the old.
+          // otherwise, just set to the new value:
+          message.data = message.data ? message.data + "\n" + value : value; // otherwise,
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          var retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            // per spec, ignore non-integers
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  var res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  // data, event, and id must be initialized to empty strings:
+  // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+  // retry should be initialized to undefined so we return a consistent shape
+  // to the js engine all the time: https://mathiasbynens.be/notes/shapes-ics#takeaways
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: undefined
+  };
+}
+
+exports.getBytes = getBytes;
+exports.getLines = getLines;
+exports.getMessages = getMessages;

package/dist/fetch-event-source/parse.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Represents a message sent in an event stream
+ * https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format
+ */
+export interface EventSourceMessage {
+    /** The event ID to set the EventSource object's last event ID value. */
+    id: string;
+    /** A string identifying the type of event described. */
+    event: string;
+    /** The event data */
+    data: string;
+    /** The reconnection interval (in milliseconds) to wait before retrying the connection */
+    retry?: number;
+}
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+export declare function getBytes(stream: ReadableStream<Uint8Array> | null, onChunk: (arr: Uint8Array) => void): Promise<void>;
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+export declare function getLines(onLine: (line: Uint8Array, fieldLength: number) => void): (arr: Uint8Array) => void;
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+export declare function getMessages(onId: (id: string) => void, onRetry: (retry: number) => void, onMessage?: (msg: EventSourceMessage) => void): (line: Uint8Array, fieldLength: number) => void;

package/dist/fetch-event-source/parse.mjs

@@ -0,0 +1,178 @@
+import _regeneratorRuntime from '@babel/runtime/helpers/regeneratorRuntime';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+
+/**
+ * Converts a ReadableStream into a callback pattern.
+ * @param stream The input ReadableStream.
+ * @param onChunk A function that will be called on each new byte chunk in the stream.
+ * @returns {Promise<void>} A promise that will be resolved when the stream closes.
+ */
+function getBytes(_x, _x2) {
+  return _getBytes.apply(this, arguments);
+}
+/**
+ * Parses arbitary byte chunks into EventSource line buffers.
+ * Each line should be of the format "field: value" and ends with \r, \n, or \r\n.
+ * @param onLine A function that will be called on each new EventSource line.
+ * @returns A function that should be called for each incoming byte chunk.
+ */
+function _getBytes() {
+  _getBytes = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(stream, onChunk) {
+    var reader, result;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (stream) {
+            _context.next = 2;
+            break;
+          }
+          return _context.abrupt("return");
+        case 2:
+          reader = stream.getReader();
+        case 3:
+          _context.next = 5;
+          return reader.read();
+        case 5:
+          if ((result = _context.sent).done) {
+            _context.next = 9;
+            break;
+          }
+          onChunk(result.value);
+          _context.next = 3;
+          break;
+        case 9:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _getBytes.apply(this, arguments);
+}
+function getLines(onLine) {
+  var buffer;
+  var position; // current read position
+  var fieldLength; // length of the `field` portion of the line
+  var discardTrailingNewline = false;
+  // return a function that can process each incoming byte chunk:
+  return function onChunk(arr) {
+    if (buffer === undefined) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      // we're still parsing the old line. Append the new bytes into buffer:
+      buffer = concat(buffer, arr);
+    }
+    var bufLength = buffer.length;
+    var lineStart = 0; // index where the current line starts
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10 /* ControlChars.NewLine */) {
+          lineStart = ++position; // skip to next char
+        }
+        discardTrailingNewline = false;
+      }
+      // start looking forward till the end of line:
+      var lineEnd = -1; // index of the \r or \n char
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58 /* ControlChars.Colon */:
+            if (fieldLength === -1) {
+              // first colon in line
+              fieldLength = position - lineStart;
+            }
+            break;
+          // @ts-ignore:7029 \r case below should fallthrough to \n:
+          case 13 /* ControlChars.CarriageReturn */:
+            discardTrailingNewline = true;
+          case 10 /* ControlChars.NewLine */:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        // We reached the end of the buffer but the line hasn't ended.
+        // Wait for the next arr and then continue parsing:
+        break;
+      }
+      // we've reached the line end, send it out:
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position; // we're now on the next line
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = undefined; // we've finished reading it
+    } else if (lineStart !== 0) {
+      // Create a new view into buffer beginning at lineStart so we don't
+      // need to copy over the previous lines when we get the new arr:
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+/**
+ * Parses line buffers into EventSourceMessages.
+ * @param onId A function that will be called on each `id` field.
+ * @param onRetry A function that will be called on each `retry` field.
+ * @param onMessage A function that will be called on each message.
+ * @returns A function that should be called for each incoming line buffer.
+ */
+function getMessages(onId, onRetry, onMessage) {
+  var message = newMessage();
+  var decoder = new TextDecoder();
+  // return a function that can process each incoming line buffer:
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      // empty line denotes end of message. Trigger the callback and start a new message:
+      onMessage === null || onMessage === void 0 || onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      // exclude comments and lines with no values
+      // line is of format "<field>:<value>" or "<field>: <value>"
+      // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+      var field = decoder.decode(line.subarray(0, fieldLength));
+      var valueOffset = fieldLength + (line[fieldLength + 1] === 32 /* ControlChars.Space */ ? 2 : 1);
+      var value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          // if this message already has data, append the new value to the old.
+          // otherwise, just set to the new value:
+          message.data = message.data ? message.data + "\n" + value : value; // otherwise,
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          var retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            // per spec, ignore non-integers
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  var res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  // data, event, and id must be initialized to empty strings:
+  // https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation
+  // retry should be initialized to undefined so we return a consistent shape
+  // to the js engine all the time: https://mathiasbynens.be/notes/shapes-ics#takeaways
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: undefined
+  };
+}
+
+export { getBytes, getLines, getMessages };

package/dist/hooks/use-event-source.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var react = require('react');
+var useMounted = require('./use-mounted.cjs');
+
+/**
+ * @description
+ * fetch event source
+ */
+var useEventSource = function useEventSource(url) {
+  var eventSourceRef = react.useRef();
+  useMounted.useMounted(function () {
+    var _eventSource = eventSourceRef.current = new EventSource(url);
+    return function () {
+      _eventSource.close();
+    };
+  });
+};
+
+exports.useEventSource = useEventSource;

package/dist/hooks/use-event-source.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @description
+ * fetch event source
+ */
+declare const useEventSource: (url: string) => void;
+export { useEventSource };

package/dist/hooks/use-event-source.mjs

@@ -0,0 +1,18 @@
+import { useRef } from 'react';
+import { useMounted } from './use-mounted.mjs';
+
+/**
+ * @description
+ * fetch event source
+ */
+var useEventSource = function useEventSource(url) {
+  var eventSourceRef = useRef();
+  useMounted(function () {
+    var _eventSource = eventSourceRef.current = new EventSource(url);
+    return function () {
+      _eventSource.close();
+    };
+  });
+};
+
+export { useEventSource };

package/dist/hooks/use-local-storage-state.cjs

@@ -2,8 +2,8 @@
 
 var useStorageState = require('./use-storage-state.cjs');
 
-var useLocalStorageState = function useLocalStorageState(key, useBy) {
-  return useStorageState.useStorageState(key, localStorage, useBy);
+var useLocalStorageState = function useLocalStorageState(key, using) {
+  return useStorageState.useStorageState(key, globalThis.localStorage, using);
 };
 
 exports.useLocalStorageState = useLocalStorageState;

package/dist/hooks/use-local-storage-state.d.ts

@@ -1,2 +1,2 @@
-import { type UseStorageStateBy } from "./use-storage-state";
-export declare const useLocalStorageState: (key: string, useBy?: UseStorageStateBy) => import("./use-storage-state").UsedStorageState;
+import { type UsingStorageState } from "./use-storage-state";
+export declare const useLocalStorageState: (key: string, using?: UsingStorageState) => import("./use-storage-state").UsedStorageState;

package/dist/hooks/use-local-storage-state.mjs

@@ -1,7 +1,7 @@
 import { useStorageState } from './use-storage-state.mjs';
 
-var useLocalStorageState = function useLocalStorageState(key, useBy) {
-  return useStorageState(key, localStorage, useBy);
+var useLocalStorageState = function useLocalStorageState(key, using) {
+  return useStorageState(key, globalThis.localStorage, using);
 };
 
 export { useLocalStorageState };

package/dist/hooks/use-raf.cjs

@@ -12,7 +12,6 @@ var useRaf = function useRaf(_callback) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
     timely = _ref.timely;
   var timed = react.useRef(null);
-  var isTimed = react.useRef(false);
   useUnmount.useUnmount(function () {
     if (!timed.current) return;
     cancelAnimationFrame(timed.current);
@@ -21,14 +20,13 @@ var useRaf = function useRaf(_callback) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    if (isTimed.current) return;
-    isTimed.current = true;
+    if (timed.current) return;
     if (timely) {
       _callback.apply(void 0, args);
       return;
     }
     timed.current = requestAnimationFrame(function () {
-      isTimed.current = false;
+      timed.current = null;
       _callback.apply(void 0, args);
     });
   });

package/dist/hooks/use-raf.mjs

@@ -10,7 +10,6 @@ var useRaf = function useRaf(_callback) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
     timely = _ref.timely;
   var timed = useRef(null);
-  var isTimed = useRef(false);
   useUnmount(function () {
     if (!timed.current) return;
     cancelAnimationFrame(timed.current);
@@ -19,14 +18,13 @@ var useRaf = function useRaf(_callback) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    if (isTimed.current) return;
-    isTimed.current = true;
+    if (timed.current) return;
     if (timely) {
       _callback.apply(void 0, args);
       return;
     }
     timed.current = requestAnimationFrame(function () {
-      isTimed.current = false;
+      timed.current = null;
       _callback.apply(void 0, args);
     });
   });

package/dist/hooks/use-session-storage-state.cjs

@@ -2,8 +2,8 @@
 
 var useStorageState = require('./use-storage-state.cjs');
 
-var useSessionStorageState = function useSessionStorageState(key, useBy) {
-  return useStorageState.useStorageState(key, sessionStorage, useBy);
+var useSessionStorageState = function useSessionStorageState(key, using) {
+  return useStorageState.useStorageState(key, sessionStorage, using);
 };
 
 exports.useSessionStorageState = useSessionStorageState;

package/dist/hooks/use-session-storage-state.d.ts

@@ -1,2 +1,2 @@
-import { type UseStorageStateBy } from "./use-storage-state";
-export declare const useSessionStorageState: (key: string, useBy?: UseStorageStateBy) => import("./use-storage-state").UsedStorageState;
+import { type UsingStorageState } from "./use-storage-state";
+export declare const useSessionStorageState: (key: string, using?: UsingStorageState) => import("./use-storage-state").UsedStorageState;

package/dist/hooks/use-session-storage-state.mjs

@@ -1,7 +1,7 @@
 import { useStorageState } from './use-storage-state.mjs';
 
-var useSessionStorageState = function useSessionStorageState(key, useBy) {
-  return useStorageState(key, sessionStorage, useBy);
+var useSessionStorageState = function useSessionStorageState(key, using) {
+  return useStorageState(key, sessionStorage, using);
 };
 
 export { useSessionStorageState };

package/dist/hooks/use-storage-state.cjs

@@ -20,8 +20,10 @@ var useStorageState = function useStorageState(key, storage) {
   }, [key]);
   react.useEffect(function () {
     var onStorageChange = function onStorageChange(event) {
+      console.log("12321321321321321");
       if (event.key !== key) return;
       if (event.storageArea !== storage) return;
+      setState(event.newValue);
     };
     // only listen with flag = `true`
     if (listen) {
@@ -33,15 +35,13 @@ var useStorageState = function useStorageState(key, storage) {
   }, [listen]);
   // change handler
   var setter = react.useCallback(function (value) {
-    if (listen) {
-      if (isNull.isNull(value)) {
-        storage.removeItem(key);
-      } else {
-        storage.setItem(key, value);
-      }
+    // handler set, change state anytime
+    setState(value);
+    if (isNull.isNull(value)) {
+      storage.removeItem(key);
       return;
     }
-    setState(value);
+    storage.setItem(key, value);
   }, [key, listen]);
   return [state, setter];
 };

package/dist/hooks/use-storage-state.d.ts

@@ -1,5 +1,5 @@
 export type UsedStorageState = [string | null, (value: string | null) => void];
-export type UseStorageStateBy = {
+export type UsingStorageState = {
     listen?: boolean;
 };
-export declare const useStorageState: (key: string, storage: Storage, { listen }?: UseStorageStateBy) => UsedStorageState;
+export declare const useStorageState: (key: string, storage: Storage, { listen }?: UsingStorageState) => UsedStorageState;

package/dist/hooks/use-storage-state.mjs

@@ -18,8 +18,10 @@ var useStorageState = function useStorageState(key, storage) {
   }, [key]);
   useEffect(function () {
     var onStorageChange = function onStorageChange(event) {
+      console.log("12321321321321321");
       if (event.key !== key) return;
       if (event.storageArea !== storage) return;
+      setState(event.newValue);
     };
     // only listen with flag = `true`
     if (listen) {
@@ -31,15 +33,13 @@ var useStorageState = function useStorageState(key, storage) {
   }, [listen]);
   // change handler
   var setter = useCallback(function (value) {
-    if (listen) {
-      if (isNull(value)) {
-        storage.removeItem(key);
-      } else {
-        storage.setItem(key, value);
-      }
+    // handler set, change state anytime
+    setState(value);
+    if (isNull(value)) {
+      storage.removeItem(key);
       return;
     }
-    setState(value);
+    storage.setItem(key, value);
   }, [key, listen]);
   return [state, setter];
 };

package/dist/index.cjs

@@ -36,6 +36,7 @@ var useReactive = require('./hooks/use-reactive.cjs');
 var useParentSize = require('./hooks/use-parent-size.cjs');
 var useScreenSize = require('./hooks/use-screen-size.cjs');
 var useDrag = require('./hooks/use-drag.cjs');
+var useEventSource = require('./hooks/use-event-source.cjs');
 var isRefable = require('./is/is-refable.cjs');
 var isUndefined = require('./is/is-undefined.cjs');
 var isNull = require('./is/is-null.cjs');
@@ -113,6 +114,7 @@ exports.useReactive = useReactive.useReactive;
 exports.useParentSize = useParentSize.useParentSize;
 exports.useScreenSize = useScreenSize.useScreenSize;
 exports.useDrag = useDrag.useDrag;
+exports.useEventSource = useEventSource.useEventSource;
 exports.isRefable = isRefable.isRefable;
 exports.isUndefined = isUndefined.isUndefined;
 exports.isNull = isNull.isNull;

package/dist/index.d.ts

@@ -38,6 +38,7 @@ export { useReactive } from "./hooks/use-reactive";
 export { useParentSize } from "./hooks/use-parent-size";
 export { useScreenSize } from "./hooks/use-screen-size";
 export { useDrag } from "./hooks/use-drag";
+export { useEventSource } from "./hooks/use-event-source";
 /**
  * @description
  * is

package/dist/index.mjs

@@ -34,6 +34,7 @@ export { useReactive } from './hooks/use-reactive.mjs';
 export { useParentSize } from './hooks/use-parent-size.mjs';
 export { useScreenSize } from './hooks/use-screen-size.mjs';
 export { useDrag } from './hooks/use-drag.mjs';
+export { useEventSource } from './hooks/use-event-source.mjs';
 export { isRefable } from './is/is-refable.mjs';
 export { isUndefined } from './is/is-undefined.mjs';
 export { isNull } from './is/is-null.mjs';

package/dist/utils/exclude.d.ts

@@ -7,4 +7,4 @@
  * @example
  * exclude([1, 2, 3, 4, 5], [2, 4]) // [1, 3, 5]
  */
-export declare const exclude: <T, E = unknown>(value: Array<T>, _excludeBy: Array<E>) => Array<Exclude<T, E>>;
+export declare const exclude: <T, E = unknown>(value: Array<T>, _excludeBy: Array<E>) => (Exclude<T, E> extends never ? T : Exclude<T, E>)[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiszlab/relax",
-  "version": "1.5.4",
+  "version": "1.5.6",
   "description": "react utils collection",
   "exports": {
     ".": {