@aiszlab/relax 1.5.3 → 1.5.5

package/dist/class-name/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var stringify = require('./stringify.cjs');
+var normalize = require('./normalize.cjs');
+
+
+
+exports.stringify = stringify.stringify;
+exports.normalize = normalize.normalize;

package/dist/class-name/index.d.ts

@@ -0,0 +1,2 @@
+export { stringify } from "./stringify";
+export { normalize } from "./normalize";

package/dist/class-name/index.mjs

@@ -0,0 +1,2 @@
+export { stringify } from './stringify.mjs';
+export { normalize } from './normalize.mjs';

package/dist/class-name/normalize.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
+var isString = require('../is/is-string.cjs');
+
+function normalize() {
+  var values = new Set();
+  for (var _len = arguments.length, classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    classNames[_key] = arguments[_key];
+  }
+  for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
+    var _classNames = _classNames2[_i];
+    if (!isString.isString(_classNames)) return;
+    var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 1),
+          className = _step$value[0];
+        values.add(className);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return Array.from(values);
+}
+
+exports.normalize = normalize;

package/dist/class-name/normalize.d.ts

@@ -0,0 +1,2 @@
+declare function normalize(...classNames: string[]): string[] | undefined;
+export { normalize };

package/dist/class-name/normalize.mjs

@@ -0,0 +1,30 @@
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _createForOfIteratorHelper from '@babel/runtime/helpers/createForOfIteratorHelper';
+import { isString } from '../is/is-string.mjs';
+
+function normalize() {
+  var values = new Set();
+  for (var _len = arguments.length, classNames = new Array(_len), _key = 0; _key < _len; _key++) {
+    classNames[_key] = arguments[_key];
+  }
+  for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
+    var _classNames = _classNames2[_i];
+    if (!isString(_classNames)) return;
+    var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var _step$value = _slicedToArray(_step.value, 1),
+          className = _step$value[0];
+        values.add(className);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return Array.from(values);
+}
+
+export { normalize };

package/dist/{utils/clsx.cjs → class-name/stringify.cjs}

@@ -8,28 +8,28 @@ var isString = require('../is/is-string.cjs');
 var isVoid = require('../is/is-void.cjs');
 
 var _toClassNames = function toClassNames(_classNames) {
-  if (isVoid.isVoid(_classNames) || isBoolean.isBoolean(_classNames)) return [];
-  if (isString.isString(_classNames) || isNumber.isNumber(_classNames)) return [_classNames.toString()];
+  if (isVoid.isVoid(_classNames) || isBoolean.isBoolean(_classNames)) return new Set();
+  if (isString.isString(_classNames) || isNumber.isNumber(_classNames)) return new Set([_classNames.toString()]);
   if (isArray.isArray(_classNames)) {
     return _classNames.reduce(function (classNames, item) {
-      return classNames.concat(_toClassNames(item));
-    }, []);
+      return classNames.union(_toClassNames(item));
+    }, new Set());
   }
   return Object.entries(_classNames).reduce(function (classNames, _ref) {
     var _ref2 = _slicedToArray(_ref, 2),
       className = _ref2[0],
       isValid = _ref2[1];
     if (isValid) {
-      classNames.push(className);
+      classNames.add(className);
     }
     return classNames;
-  }, []);
+  }, new Set());
 };
-var clsx = function clsx() {
+var stringify = function stringify() {
   for (var _len = arguments.length, _classNames = new Array(_len), _key = 0; _key < _len; _key++) {
     _classNames[_key] = arguments[_key];
   }
-  return _toClassNames(_classNames).join(" ");
+  return Array.from(_toClassNames(_classNames)).join(" ");
 };
 
-exports.clsx = clsx;
+exports.stringify = stringify;

package/dist/{utils/clsx.d.ts → class-name/stringify.d.ts}

@@ -1,3 +1,3 @@
 type ClassNames = string | number | Record<string, boolean> | ClassNames[] | null | undefined | boolean;
-export declare const clsx: (..._classNames: ClassNames[]) => string;
+export declare const stringify: (..._classNames: ClassNames[]) => string;
 export {};

package/dist/{utils/clsx.mjs → class-name/stringify.mjs}

@@ -6,28 +6,28 @@ import { isString } from '../is/is-string.mjs';
 import { isVoid } from '../is/is-void.mjs';
 
 var _toClassNames = function toClassNames(_classNames) {
-  if (isVoid(_classNames) || isBoolean(_classNames)) return [];
-  if (isString(_classNames) || isNumber(_classNames)) return [_classNames.toString()];
+  if (isVoid(_classNames) || isBoolean(_classNames)) return new Set();
+  if (isString(_classNames) || isNumber(_classNames)) return new Set([_classNames.toString()]);
   if (isArray(_classNames)) {
     return _classNames.reduce(function (classNames, item) {
-      return classNames.concat(_toClassNames(item));
-    }, []);
+      return classNames.union(_toClassNames(item));
+    }, new Set());
   }
   return Object.entries(_classNames).reduce(function (classNames, _ref) {
     var _ref2 = _slicedToArray(_ref, 2),
       className = _ref2[0],
       isValid = _ref2[1];
     if (isValid) {
-      classNames.push(className);
+      classNames.add(className);
     }
     return classNames;
-  }, []);
+  }, new Set());
 };
-var clsx = function clsx() {
+var stringify = function stringify() {
   for (var _len = arguments.length, _classNames = new Array(_len), _key = 0; _key < _len; _key++) {
     _classNames[_key] = arguments[_key];
   }
-  return _toClassNames(_classNames).join(" ");
+  return Array.from(_toClassNames(_classNames)).join(" ");
 };
 
-export { clsx };
+export { stringify };

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';