@majoo-ui/react 1.59.6-rc.5 → 1.59.6-rc.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/index.esm.js +1484 -1497
  2. package/index.umd.js +1521 -1574
  3. package/package.json +1 -1
package/index.esm.js CHANGED
@@ -4870,1640 +4870,1640 @@ Progress$1.defaultProps = {
4870
4870
 
4871
4871
  const ToastContext = /*#__PURE__*/React.createContext({});
4872
4872
 
4873
- var classof$6 = classofRaw$2;
4874
-
4875
- var engineIsNode = typeof process != 'undefined' && classof$6(process) == 'process';
4876
-
4877
- var getBuiltIn$3 = getBuiltIn$7;
4878
- var defineBuiltInAccessor$2 = defineBuiltInAccessor$4;
4879
- var wellKnownSymbol$c = wellKnownSymbol$l;
4880
- var DESCRIPTORS$4 = descriptors;
4881
-
4882
- var SPECIES$3 = wellKnownSymbol$c('species');
4873
+ var $$l = _export;
4874
+ var $includes = arrayIncludes.includes;
4875
+ var fails$h = fails$t;
4876
+ var addToUnscopables = addToUnscopables$2;
4883
4877
 
4884
- var setSpecies$2 = function (CONSTRUCTOR_NAME) {
4885
- var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
4878
+ // FF99+ bug
4879
+ var BROKEN_ON_SPARSE = fails$h(function () {
4880
+ // eslint-disable-next-line es/no-array-prototype-includes -- detection
4881
+ return !Array(1).includes();
4882
+ });
4886
4883
 
4887
- if (DESCRIPTORS$4 && Constructor && !Constructor[SPECIES$3]) {
4888
- defineBuiltInAccessor$2(Constructor, SPECIES$3, {
4889
- configurable: true,
4890
- get: function () { return this; }
4891
- });
4884
+ // `Array.prototype.includes` method
4885
+ // https://tc39.es/ecma262/#sec-array.prototype.includes
4886
+ $$l({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
4887
+ includes: function includes(el /* , fromIndex = 0 */) {
4888
+ return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
4892
4889
  }
4893
- };
4894
-
4895
- var isPrototypeOf$3 = objectIsPrototypeOf;
4896
-
4897
- var $TypeError$9 = TypeError;
4898
-
4899
- var anInstance$3 = function (it, Prototype) {
4900
- if (isPrototypeOf$3(Prototype, it)) return it;
4901
- throw $TypeError$9('Incorrect invocation');
4902
- };
4890
+ });
4903
4891
 
4904
- var uncurryThis$n = functionUncurryThis;
4905
- var fails$h = fails$t;
4906
- var isCallable$8 = isCallable$p;
4907
- var classof$5 = classof$8;
4908
- var getBuiltIn$2 = getBuiltIn$7;
4909
- var inspectSource$1 = inspectSource$3;
4892
+ // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
4893
+ addToUnscopables('includes');
4910
4894
 
4911
- var noop$1 = function () { /* empty */ };
4912
- var empty = [];
4913
- var construct = getBuiltIn$2('Reflect', 'construct');
4914
- var constructorRegExp = /^\s*(?:class|function)\b/;
4915
- var exec$6 = uncurryThis$n(constructorRegExp.exec);
4916
- var INCORRECT_TO_STRING = !constructorRegExp.exec(noop$1);
4895
+ var isObject$7 = isObject$e;
4896
+ var classof$6 = classofRaw$2;
4897
+ var wellKnownSymbol$c = wellKnownSymbol$l;
4917
4898
 
4918
- var isConstructorModern = function isConstructor(argument) {
4919
- if (!isCallable$8(argument)) return false;
4920
- try {
4921
- construct(noop$1, empty, argument);
4922
- return true;
4923
- } catch (error) {
4924
- return false;
4925
- }
4926
- };
4899
+ var MATCH$2 = wellKnownSymbol$c('match');
4927
4900
 
4928
- var isConstructorLegacy = function isConstructor(argument) {
4929
- if (!isCallable$8(argument)) return false;
4930
- switch (classof$5(argument)) {
4931
- case 'AsyncFunction':
4932
- case 'GeneratorFunction':
4933
- case 'AsyncGeneratorFunction': return false;
4934
- }
4935
- try {
4936
- // we can't check .prototype since constructors produced by .bind haven't it
4937
- // `Function#toString` throws on some built-it function in some legacy engines
4938
- // (for example, `DOMQuad` and similar in FF41-)
4939
- return INCORRECT_TO_STRING || !!exec$6(constructorRegExp, inspectSource$1(argument));
4940
- } catch (error) {
4941
- return true;
4942
- }
4901
+ // `IsRegExp` abstract operation
4902
+ // https://tc39.es/ecma262/#sec-isregexp
4903
+ var isRegexp = function (it) {
4904
+ var isRegExp;
4905
+ return isObject$7(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classof$6(it) == 'RegExp');
4943
4906
  };
4944
4907
 
4945
- isConstructorLegacy.sham = true;
4946
-
4947
- // `IsConstructor` abstract operation
4948
- // https://tc39.es/ecma262/#sec-isconstructor
4949
- var isConstructor$2 = !construct || fails$h(function () {
4950
- var called;
4951
- return isConstructorModern(isConstructorModern.call)
4952
- || !isConstructorModern(Object)
4953
- || !isConstructorModern(function () { called = true; })
4954
- || called;
4955
- }) ? isConstructorLegacy : isConstructorModern;
4956
-
4957
- var isConstructor$1 = isConstructor$2;
4958
- var tryToString$3 = tryToString$5;
4908
+ var isRegExp$2 = isRegexp;
4959
4909
 
4960
- var $TypeError$8 = TypeError;
4910
+ var $TypeError$9 = TypeError;
4961
4911
 
4962
- // `Assert: IsConstructor(argument) is true`
4963
- var aConstructor$1 = function (argument) {
4964
- if (isConstructor$1(argument)) return argument;
4965
- throw $TypeError$8(tryToString$3(argument) + ' is not a constructor');
4912
+ var notARegexp = function (it) {
4913
+ if (isRegExp$2(it)) {
4914
+ throw $TypeError$9("The method doesn't accept regular expressions");
4915
+ } return it;
4966
4916
  };
4967
4917
 
4968
- var anObject$d = anObject$j;
4969
- var aConstructor = aConstructor$1;
4970
- var isNullOrUndefined$5 = isNullOrUndefined$8;
4971
4918
  var wellKnownSymbol$b = wellKnownSymbol$l;
4972
4919
 
4973
- var SPECIES$2 = wellKnownSymbol$b('species');
4920
+ var MATCH$1 = wellKnownSymbol$b('match');
4974
4921
 
4975
- // `SpeciesConstructor` abstract operation
4976
- // https://tc39.es/ecma262/#sec-speciesconstructor
4977
- var speciesConstructor$2 = function (O, defaultConstructor) {
4978
- var C = anObject$d(O).constructor;
4979
- var S;
4980
- return C === undefined || isNullOrUndefined$5(S = anObject$d(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
4922
+ var correctIsRegexpLogic = function (METHOD_NAME) {
4923
+ var regexp = /./;
4924
+ try {
4925
+ '/./'[METHOD_NAME](regexp);
4926
+ } catch (error1) {
4927
+ try {
4928
+ regexp[MATCH$1] = false;
4929
+ return '/./'[METHOD_NAME](regexp);
4930
+ } catch (error2) { /* empty */ }
4931
+ } return false;
4981
4932
  };
4982
4933
 
4983
- var NATIVE_BIND$1 = functionBindNative;
4934
+ var $$k = _export;
4935
+ var uncurryThis$n = functionUncurryThis;
4936
+ var notARegExp$2 = notARegexp;
4937
+ var requireObjectCoercible$9 = requireObjectCoercible$c;
4938
+ var toString$h = toString$j;
4939
+ var correctIsRegExpLogic$2 = correctIsRegexpLogic;
4984
4940
 
4985
- var FunctionPrototype = Function.prototype;
4986
- var apply$3 = FunctionPrototype.apply;
4987
- var call$h = FunctionPrototype.call;
4941
+ var stringIndexOf$2 = uncurryThis$n(''.indexOf);
4988
4942
 
4989
- // eslint-disable-next-line es/no-reflect -- safe
4990
- var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$h.bind(apply$3) : function () {
4991
- return call$h.apply(apply$3, arguments);
4943
+ // `String.prototype.includes` method
4944
+ // https://tc39.es/ecma262/#sec-string.prototype.includes
4945
+ $$k({ target: 'String', proto: true, forced: !correctIsRegExpLogic$2('includes') }, {
4946
+ includes: function includes(searchString /* , position = 0 */) {
4947
+ return !!~stringIndexOf$2(
4948
+ toString$h(requireObjectCoercible$9(this)),
4949
+ toString$h(notARegExp$2(searchString)),
4950
+ arguments.length > 1 ? arguments[1] : undefined
4951
+ );
4952
+ }
4992
4953
  });
4993
4954
 
4994
- var classofRaw = classofRaw$2;
4995
- var uncurryThis$m = functionUncurryThis;
4996
-
4997
- var functionUncurryThisClause = function (fn) {
4998
- // Nashorn bug:
4999
- // https://github.com/zloirock/core-js/issues/1128
5000
- // https://github.com/zloirock/core-js/issues/1130
5001
- if (classofRaw(fn) === 'Function') return uncurryThis$m(fn);
5002
- };
5003
-
5004
- var uncurryThis$l = functionUncurryThisClause;
5005
- var aCallable$7 = aCallable$a;
5006
- var NATIVE_BIND = functionBindNative;
5007
-
5008
- var bind$7 = uncurryThis$l(uncurryThis$l.bind);
5009
-
5010
- // optional / simple context binding
5011
- var functionBindContext = function (fn, that) {
5012
- aCallable$7(fn);
5013
- return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) {
5014
- return fn.apply(that, arguments);
5015
- };
5016
- };
5017
-
5018
- var uncurryThis$k = functionUncurryThis;
5019
-
5020
- var arraySlice$4 = uncurryThis$k([].slice);
5021
-
5022
- var $TypeError$7 = TypeError;
5023
-
5024
- var validateArgumentsLength$3 = function (passed, required) {
5025
- if (passed < required) throw $TypeError$7('Not enough arguments');
5026
- return passed;
5027
- };
5028
-
5029
- var userAgent$4 = engineUserAgent;
5030
-
5031
- // eslint-disable-next-line redos/no-vulnerable -- safe
5032
- var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4);
5033
-
5034
- var global$d = global$p;
5035
- var apply$2 = functionApply;
5036
- var bind$6 = functionBindContext;
5037
- var isCallable$7 = isCallable$p;
5038
- var hasOwn$4 = hasOwnProperty_1;
5039
- var fails$g = fails$t;
5040
- var html = html$2;
5041
- var arraySlice$3 = arraySlice$4;
5042
- var createElement = documentCreateElement$2;
5043
- var validateArgumentsLength$2 = validateArgumentsLength$3;
5044
- var IS_IOS$1 = engineIsIos;
5045
- var IS_NODE$4 = engineIsNode;
5046
-
5047
- var set = global$d.setImmediate;
5048
- var clear = global$d.clearImmediate;
5049
- var process$3 = global$d.process;
5050
- var Dispatch = global$d.Dispatch;
5051
- var Function$1 = global$d.Function;
5052
- var MessageChannel = global$d.MessageChannel;
5053
- var String$1 = global$d.String;
5054
- var counter = 0;
5055
- var queue$2 = {};
5056
- var ONREADYSTATECHANGE = 'onreadystatechange';
5057
- var $location, defer, channel, port;
4955
+ function useMediaQuery(query) {
4956
+ const [matches, setMatches] = useState(false);
4957
+ useEffect(() => {
4958
+ const media = window.matchMedia(query);
4959
+ if (media.matches !== matches) {
4960
+ setMatches(media.matches);
4961
+ }
4962
+ const listener = () => {
4963
+ setMatches(media.matches);
4964
+ };
4965
+ media.addEventListener('change', listener);
4966
+ return () => media.removeEventListener('change', listener);
4967
+ }, [matches, query]);
4968
+ return matches;
4969
+ }
5058
4970
 
5059
- fails$g(function () {
5060
- // Deno throws a ReferenceError on `location` access without `--location` flag
5061
- $location = global$d.location;
4971
+ const _excluded$t = ["id", "title", "description", "position", "dismissAfter", "variant", "onClick", "onRemove", "isExternalOfAction", "onClickOfAction", "captionOfAction", "hrefOfAction"];
4972
+ var _jsxFileName$V = "/home/alfiantryp/Projects/majoo-ui/packages/react/src/components/toast/Toast.js";
4973
+ const TOAST_WIDTH = 576;
4974
+ const ANIMATION_DURATION = 400;
4975
+ const TOP_RIGHT_POSITION = 'top-right';
4976
+ const TOP_LEFT_POSITION = 'top-left';
4977
+ const BOTTOM_RIGHT_POSITION = 'bottom-right';
4978
+ const BOTTOM_LEFT_POSITION = 'bottom_left';
4979
+ const positions = [TOP_RIGHT_POSITION, TOP_LEFT_POSITION, BOTTOM_RIGHT_POSITION, BOTTOM_LEFT_POSITION];
4980
+ const toastEnter = position => keyframes({
4981
+ '0%': {
4982
+ left: position === 'left' ? `-${TOAST_WIDTH}px` : 'unset',
4983
+ right: position === 'right' ? `-${TOAST_WIDTH}px` : 'unset',
4984
+ opacity: '0'
4985
+ },
4986
+ '100%': {
4987
+ left: position === 'left' ? '0' : 'unset',
4988
+ right: position === 'right' ? '0' : 'unset',
4989
+ opacity: '1'
4990
+ }
5062
4991
  });
5063
-
5064
- var run = function (id) {
5065
- if (hasOwn$4(queue$2, id)) {
5066
- var fn = queue$2[id];
5067
- delete queue$2[id];
5068
- fn();
4992
+ const toastExit = position => keyframes({
4993
+ '0%': {
4994
+ transform: 'translateX(0%)',
4995
+ opacity: '1'
4996
+ },
4997
+ '100%': {
4998
+ transform: `translateX(${position === 'right' ? '100%' : '-100%'})`,
4999
+ opacity: '0'
5069
5000
  }
5070
- };
5071
-
5072
- var runner = function (id) {
5073
- return function () {
5074
- run(id);
5075
- };
5076
- };
5077
-
5078
- var eventListener = function (event) {
5079
- run(event.data);
5080
- };
5081
-
5082
- var globalPostMessageDefer = function (id) {
5083
- // old engines have not location.origin
5084
- global$d.postMessage(String$1(id), $location.protocol + '//' + $location.host);
5085
- };
5086
-
5087
- // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
5088
- if (!set || !clear) {
5089
- set = function setImmediate(handler) {
5090
- validateArgumentsLength$2(arguments.length, 1);
5091
- var fn = isCallable$7(handler) ? handler : Function$1(handler);
5092
- var args = arraySlice$3(arguments, 1);
5093
- queue$2[++counter] = function () {
5094
- apply$2(fn, undefined, args);
5095
- };
5096
- defer(counter);
5097
- return counter;
5098
- };
5099
- clear = function clearImmediate(id) {
5100
- delete queue$2[id];
5101
- };
5102
- // Node.js 0.8-
5103
- if (IS_NODE$4) {
5104
- defer = function (id) {
5105
- process$3.nextTick(runner(id));
5106
- };
5107
- // Sphere (JS game engine) Dispatch API
5108
- } else if (Dispatch && Dispatch.now) {
5109
- defer = function (id) {
5110
- Dispatch.now(runner(id));
5111
- };
5112
- // Browsers with MessageChannel, includes WebWorkers
5113
- // except iOS - https://github.com/zloirock/core-js/issues/624
5114
- } else if (MessageChannel && !IS_IOS$1) {
5115
- channel = new MessageChannel();
5116
- port = channel.port2;
5117
- channel.port1.onmessage = eventListener;
5118
- defer = bind$6(port.postMessage, port);
5119
- // Browsers with postMessage, skip WebWorkers
5120
- // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
5121
- } else if (
5122
- global$d.addEventListener &&
5123
- isCallable$7(global$d.postMessage) &&
5124
- !global$d.importScripts &&
5125
- $location && $location.protocol !== 'file:' &&
5126
- !fails$g(globalPostMessageDefer)
5127
- ) {
5128
- defer = globalPostMessageDefer;
5129
- global$d.addEventListener('message', eventListener, false);
5130
- // IE8-
5131
- } else if (ONREADYSTATECHANGE in createElement('script')) {
5132
- defer = function (id) {
5133
- html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
5134
- html.removeChild(this);
5135
- run(id);
5136
- };
5137
- };
5138
- // Rest old browsers
5139
- } else {
5140
- defer = function (id) {
5141
- setTimeout(runner(id), 0);
5142
- };
5143
- }
5144
- }
5145
-
5146
- var task$1 = {
5147
- set: set,
5148
- clear: clear
5149
- };
5150
-
5151
- var Queue$2 = function () {
5152
- this.head = null;
5153
- this.tail = null;
5154
- };
5155
-
5156
- Queue$2.prototype = {
5157
- add: function (item) {
5158
- var entry = { item: item, next: null };
5159
- var tail = this.tail;
5160
- if (tail) tail.next = entry;
5161
- else this.head = entry;
5162
- this.tail = entry;
5001
+ });
5002
+ const toastAnimationStyle = position => ({
5003
+ '&[state="entering"], &[state="entered"]': {
5004
+ animationFillMode: 'forwards',
5005
+ animationName: toastEnter(position),
5006
+ animationDuration: `${ANIMATION_DURATION}ms`
5163
5007
  },
5164
- get: function () {
5165
- var entry = this.head;
5166
- if (entry) {
5167
- var next = this.head = entry.next;
5168
- if (next === null) this.tail = null;
5169
- return entry.item;
5008
+ '&[state="exiting"]': {
5009
+ animationFillMode: 'forwards',
5010
+ animationName: toastExit(position),
5011
+ animationDuration: `${ANIMATION_DURATION * 2}ms`
5012
+ },
5013
+ '&[state="entered"]': {
5014
+ right: 0,
5015
+ opacity: '1'
5016
+ }
5017
+ });
5018
+ const Root = styled('div', {
5019
+ display: 'block',
5020
+ maxWidth: `${TOAST_WIDTH}px`,
5021
+ // width: `${TOAST_WIDTH}px`,
5022
+ height: '100%',
5023
+ position: 'relative',
5024
+ opacity: 0,
5025
+ variants: {
5026
+ hPosition: {
5027
+ right: toastAnimationStyle('right'),
5028
+ left: toastAnimationStyle('left')
5029
+ },
5030
+ vPosition: {
5031
+ top: {
5032
+ marginTop: '$spacing-05'
5033
+ },
5034
+ bottom: {
5035
+ marginBottom: '$spacing-05'
5036
+ }
5170
5037
  }
5171
5038
  }
5172
- };
5173
-
5174
- var queue$1 = Queue$2;
5175
-
5176
- var userAgent$3 = engineUserAgent;
5177
-
5178
- var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined';
5179
-
5180
- var userAgent$2 = engineUserAgent;
5181
-
5182
- var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2);
5183
-
5184
- var global$c = global$p;
5185
- var bind$5 = functionBindContext;
5186
- var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f;
5187
- var macrotask = task$1.set;
5188
- var Queue$1 = queue$1;
5189
- var IS_IOS = engineIsIos;
5190
- var IS_IOS_PEBBLE = engineIsIosPebble;
5191
- var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
5192
- var IS_NODE$3 = engineIsNode;
5193
-
5194
- var MutationObserver = global$c.MutationObserver || global$c.WebKitMutationObserver;
5195
- var document$2 = global$c.document;
5196
- var process$2 = global$c.process;
5197
- var Promise$1 = global$c.Promise;
5198
- // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
5199
- var queueMicrotaskDescriptor = getOwnPropertyDescriptor$3(global$c, 'queueMicrotask');
5200
- var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
5201
- var notify$1, toggle, node, promise, then;
5202
-
5203
- // modern engines have queueMicrotask method
5204
- if (!microtask$1) {
5205
- var queue = new Queue$1();
5206
-
5207
- var flush = function () {
5208
- var parent, fn;
5209
- if (IS_NODE$3 && (parent = process$2.domain)) parent.exit();
5210
- while (fn = queue.get()) try {
5211
- fn();
5212
- } catch (error) {
5213
- if (queue.head) notify$1();
5214
- throw error;
5039
+ });
5040
+ const StyledToast = styled(Flex$1, {
5041
+ // width: '100%',
5042
+ // maxWidth: TOAST_WIDTH,
5043
+ padding: '$spacing-03',
5044
+ textAlign: 'left',
5045
+ borderRadius: 8,
5046
+ pointer: 'default',
5047
+ variants: {
5048
+ variant: {
5049
+ info: {
5050
+ backgroundColor: '$blue100',
5051
+ border: '1px solid $hlNews'
5052
+ },
5053
+ warning: {
5054
+ backgroundColor: '$bgProcess',
5055
+ border: '1px solid $hlProcess'
5056
+ },
5057
+ success: {
5058
+ backgroundColor: '$bgSuccess',
5059
+ border: '1px solid $hlSuccess'
5060
+ },
5061
+ failed: {
5062
+ backgroundColor: '$bgFailed',
5063
+ border: '1px solid $hlFailed'
5064
+ },
5065
+ pending: {
5066
+ backgroundColor: '$bgProcess',
5067
+ border: '1px solid $orange500'
5068
+ }
5069
+ },
5070
+ hasAction: {
5071
+ true: {
5072
+ cursor: 'pointer'
5073
+ }
5215
5074
  }
5216
- if (parent) parent.enter();
5217
- };
5218
-
5219
- // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
5220
- // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
5221
- if (!IS_IOS && !IS_NODE$3 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
5222
- toggle = true;
5223
- node = document$2.createTextNode('');
5224
- new MutationObserver(flush).observe(node, { characterData: true });
5225
- notify$1 = function () {
5226
- node.data = toggle = !toggle;
5227
- };
5228
- // environments with maybe non-completely correct, but existent Promise
5229
- } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
5230
- // Promise.resolve without an argument throws an error in LG WebOS 2
5231
- promise = Promise$1.resolve(undefined);
5232
- // workaround of WebKit ~ iOS Safari 10.1 bug
5233
- promise.constructor = Promise$1;
5234
- then = bind$5(promise.then, promise);
5235
- notify$1 = function () {
5236
- then(flush);
5237
- };
5238
- // Node.js without promises
5239
- } else if (IS_NODE$3) {
5240
- notify$1 = function () {
5241
- process$2.nextTick(flush);
5242
- };
5243
- // for other environments - macrotask based on:
5244
- // - setImmediate
5245
- // - MessageChannel
5246
- // - window.postMessage
5247
- // - onreadystatechange
5248
- // - setTimeout
5249
- } else {
5250
- // `webpack` dev server bug on IE global methods - use bind(fn, global)
5251
- macrotask = bind$5(macrotask, global$c);
5252
- notify$1 = function () {
5253
- macrotask(flush);
5254
- };
5255
5075
  }
5256
-
5257
- microtask$1 = function (fn) {
5258
- if (!queue.head) notify$1();
5259
- queue.add(fn);
5260
- };
5261
- }
5262
-
5263
- var microtask_1 = microtask$1;
5264
-
5265
- var hostReportErrors$1 = function (a, b) {
5266
- try {
5267
- // eslint-disable-next-line no-console -- safe
5268
- arguments.length == 1 ? console.error(a) : console.error(a, b);
5269
- } catch (error) { /* empty */ }
5270
- };
5271
-
5272
- var perform$3 = function (exec) {
5273
- try {
5274
- return { error: false, value: exec() };
5275
- } catch (error) {
5276
- return { error: true, value: error };
5076
+ });
5077
+ const LeftBar = styled('div', {
5078
+ width: '4px',
5079
+ alignSelf: 'stretch',
5080
+ borderRadius: '$lg',
5081
+ marginRight: '$spacing-03',
5082
+ variants: {
5083
+ variant: {
5084
+ info: {
5085
+ backgroundColor: '$hlNews'
5086
+ },
5087
+ warning: {
5088
+ backgroundColor: '$hlProcess'
5089
+ },
5090
+ success: {
5091
+ backgroundColor: '$hlSuccess'
5092
+ },
5093
+ failed: {
5094
+ backgroundColor: '$hlFailed'
5095
+ },
5096
+ pending: {
5097
+ backgroundColor: '$orange500'
5098
+ }
5099
+ }
5100
+ }
5101
+ });
5102
+ const DescriptionField = styled(Paragraph, {
5103
+ display: '-webkit-box',
5104
+ '-webkit-line-clamp': '3',
5105
+ '-webkit-box-orient': 'vertical',
5106
+ overflow: 'hidden',
5107
+ whiteSpace: 'unset'
5108
+ });
5109
+ const CloseButton$1 = styled(Flex$1, {
5110
+ cursor: 'pointer',
5111
+ size: '20px',
5112
+ borderRadius: '$round',
5113
+ '&:hover': {
5114
+ backgroundColor: 'rgba(0, 0, 0, .05)'
5115
+ },
5116
+ alignSelf: 'start',
5117
+ variants: {
5118
+ hasTitle: {
5119
+ false: {
5120
+ alignSelf: 'center'
5121
+ }
5122
+ }
5277
5123
  }
5124
+ });
5125
+ const Toast = _ref => {
5126
+ let {
5127
+ id,
5128
+ title,
5129
+ description,
5130
+ position,
5131
+ dismissAfter,
5132
+ variant,
5133
+ onClick,
5134
+ onRemove,
5135
+ isExternalOfAction,
5136
+ onClickOfAction,
5137
+ captionOfAction,
5138
+ hrefOfAction
5139
+ } = _ref,
5140
+ rest = _objectWithoutPropertiesLoose(_ref, _excluded$t);
5141
+ const [isOpen, setIsOpen] = React.useState(false);
5142
+ const isMobile = useMediaQuery(`(max-width: 767px`);
5143
+ const close = React.useCallback(() => {
5144
+ setIsOpen(false);
5145
+ }, [setIsOpen]);
5146
+ React.useEffect(() => {
5147
+ let currentTimer = null;
5148
+ setIsOpen(true);
5149
+ currentTimer = setTimeout(() => {
5150
+ close();
5151
+ }, dismissAfter);
5152
+ return () => {
5153
+ if (currentTimer) {
5154
+ clearTimeout(currentTimer);
5155
+ }
5156
+ };
5157
+ }, [dismissAfter]);
5158
+ return /*#__PURE__*/React.createElement(Transition, {
5159
+ appear: true,
5160
+ in: isOpen,
5161
+ timeout: {
5162
+ enter: ANIMATION_DURATION + 100,
5163
+ exit: ANIMATION_DURATION + 400
5164
+ },
5165
+ unmountOnExit: true,
5166
+ onExited: onRemove,
5167
+ __self: undefined,
5168
+ __source: {
5169
+ fileName: _jsxFileName$V,
5170
+ lineNumber: 216,
5171
+ columnNumber: 5
5172
+ }
5173
+ }, state => /*#__PURE__*/React.createElement(Root, _extends({
5174
+ id: id,
5175
+ state: state,
5176
+ css: {
5177
+ maxWidth: isMobile ? '80vw' : TOAST_WIDTH
5178
+ },
5179
+ hPosition: position.includes('left') ? 'left' : 'right',
5180
+ vPosition: position.includes('top') ? 'top' : 'bottom'
5181
+ }, rest, {
5182
+ __self: undefined,
5183
+ __source: {
5184
+ fileName: _jsxFileName$V,
5185
+ lineNumber: 227,
5186
+ columnNumber: 9
5187
+ }
5188
+ }), /*#__PURE__*/React.createElement(StyledToast, {
5189
+ variant: variant,
5190
+ hasAction: !!onClick,
5191
+ onClick: onClick,
5192
+ __self: undefined,
5193
+ __source: {
5194
+ fileName: _jsxFileName$V,
5195
+ lineNumber: 235,
5196
+ columnNumber: 11
5197
+ }
5198
+ }, /*#__PURE__*/React.createElement(Flex$1, {
5199
+ direction: "column",
5200
+ __self: undefined,
5201
+ __source: {
5202
+ fileName: _jsxFileName$V,
5203
+ lineNumber: 236,
5204
+ columnNumber: 13
5205
+ }
5206
+ }, /*#__PURE__*/React.createElement(Flex$1, {
5207
+ direction: "row",
5208
+ __self: undefined,
5209
+ __source: {
5210
+ fileName: _jsxFileName$V,
5211
+ lineNumber: 237,
5212
+ columnNumber: 15
5213
+ }
5214
+ }, /*#__PURE__*/React.createElement(LeftBar, {
5215
+ variant: variant,
5216
+ __self: undefined,
5217
+ __source: {
5218
+ fileName: _jsxFileName$V,
5219
+ lineNumber: 238,
5220
+ columnNumber: 17
5221
+ }
5222
+ }), /*#__PURE__*/React.createElement(Flex$1, {
5223
+ gap: 2,
5224
+ direction: "column",
5225
+ css: {
5226
+ flex: 1
5227
+ },
5228
+ __self: undefined,
5229
+ __source: {
5230
+ fileName: _jsxFileName$V,
5231
+ lineNumber: 239,
5232
+ columnNumber: 17
5233
+ }
5234
+ }, title && /*#__PURE__*/React.createElement(Flex$1, {
5235
+ justify: "between",
5236
+ __self: undefined,
5237
+ __source: {
5238
+ fileName: _jsxFileName$V,
5239
+ lineNumber: 247,
5240
+ columnNumber: 21
5241
+ }
5242
+ }, /*#__PURE__*/React.createElement(Heading, {
5243
+ heading: "sectionTitle",
5244
+ css: {
5245
+ lineHeight: '$long-content-regular',
5246
+ flex: 1,
5247
+ whiteSpace: 'unset',
5248
+ overflow: 'hidden',
5249
+ textOverflow: 'ellipsis'
5250
+ },
5251
+ __self: undefined,
5252
+ __source: {
5253
+ fileName: _jsxFileName$V,
5254
+ lineNumber: 248,
5255
+ columnNumber: 23
5256
+ }
5257
+ }, title)), /*#__PURE__*/React.createElement(DescriptionField, {
5258
+ paragraph: "longContentRegular",
5259
+ color: "secondary",
5260
+ __self: undefined,
5261
+ __source: {
5262
+ fileName: _jsxFileName$V,
5263
+ lineNumber: 262,
5264
+ columnNumber: 19
5265
+ }
5266
+ }, description)), /*#__PURE__*/React.createElement(CloseButton$1, {
5267
+ onClick: e => {
5268
+ e.preventDefault();
5269
+ e.stopPropagation();
5270
+ close();
5271
+ },
5272
+ align: "center",
5273
+ justify: "center",
5274
+ hasTitle: !!title,
5275
+ __self: undefined,
5276
+ __source: {
5277
+ fileName: _jsxFileName$V,
5278
+ lineNumber: 266,
5279
+ columnNumber: 17
5280
+ }
5281
+ }, /*#__PURE__*/React.createElement(CloseOutline, {
5282
+ color: colors$8.iconSecondary,
5283
+ size: "16px",
5284
+ __self: undefined,
5285
+ __source: {
5286
+ fileName: _jsxFileName$V,
5287
+ lineNumber: 276,
5288
+ columnNumber: 19
5289
+ }
5290
+ }))), (hrefOfAction || isExternalOfAction || onClickOfAction) && /*#__PURE__*/React.createElement(Link, {
5291
+ href: hrefOfAction,
5292
+ isExternal: isExternalOfAction,
5293
+ onClick: onClickOfAction,
5294
+ color: variant,
5295
+ css: {
5296
+ alignSelf: 'self-end',
5297
+ marginTop: '$spacing-03'
5298
+ },
5299
+ __self: undefined,
5300
+ __source: {
5301
+ fileName: _jsxFileName$V,
5302
+ lineNumber: 280,
5303
+ columnNumber: 17
5304
+ }
5305
+ }, captionOfAction)))));
5306
+ };
5307
+ Toast.displayName = 'Toast';
5308
+ Toast.propTypes = {
5309
+ id: PropTypes.string,
5310
+ title: PropTypes.string,
5311
+ description: PropTypes.string,
5312
+ position: PropTypes.oneOf(positions).isRequired,
5313
+ dismissAfter: PropTypes.number,
5314
+ variant: PropTypes.string.isRequired,
5315
+ onClick: PropTypes.func,
5316
+ onRemove: PropTypes.func,
5317
+ disabledOfflineIntercept: PropTypes.bool
5318
+ };
5319
+ Toast.defaultProps = {
5320
+ dismissAfter: 5000
5278
5321
  };
5279
5322
 
5280
- var global$b = global$p;
5281
-
5282
- var promiseNativeConstructor = global$b.Promise;
5283
-
5284
- /* global Deno -- Deno case */
5285
-
5286
- var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
5287
-
5288
- var IS_DENO$1 = engineIsDeno;
5289
- var IS_NODE$2 = engineIsNode;
5290
-
5291
- var engineIsBrowser = !IS_DENO$1 && !IS_NODE$2
5292
- && typeof window == 'object'
5293
- && typeof document == 'object';
5294
-
5295
- var global$a = global$p;
5296
- var NativePromiseConstructor$3 = promiseNativeConstructor;
5297
- var isCallable$6 = isCallable$p;
5298
- var isForced$1 = isForced_1;
5299
- var inspectSource = inspectSource$3;
5300
- var wellKnownSymbol$a = wellKnownSymbol$l;
5301
- var IS_BROWSER = engineIsBrowser;
5302
- var IS_DENO = engineIsDeno;
5303
- var V8_VERSION = engineV8Version;
5304
-
5305
- NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
5306
- var SPECIES$1 = wellKnownSymbol$a('species');
5307
- var SUBCLASSING = false;
5308
- var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$6(global$a.PromiseRejectionEvent);
5309
-
5310
- var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () {
5311
- var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
5312
- var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3);
5313
- // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
5314
- // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
5315
- // We can't detect it synchronously, so just check versions
5316
- if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
5317
- // We can't use @@species feature detection in V8 since it causes
5318
- // deoptimization and performance degradation
5319
- // https://github.com/zloirock/core-js/issues/679
5320
- if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
5321
- // Detect correctness of subclassing with @@species support
5322
- var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); });
5323
- var FakePromise = function (exec) {
5324
- exec(function () { /* empty */ }, function () { /* empty */ });
5325
- };
5326
- var constructor = promise.constructor = {};
5327
- constructor[SPECIES$1] = FakePromise;
5328
- SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
5329
- if (!SUBCLASSING) return true;
5330
- // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
5331
- } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
5323
+ const _excluded$s = ["preventDuplicate"];
5324
+ var _jsxFileName$U = "/home/alfiantryp/Projects/majoo-ui/packages/react/src/components/toast/ToastContainer.js";
5325
+ const ToastBox = styled(Flex$1, {
5326
+ position: 'fixed',
5327
+ variants: {
5328
+ position: {
5329
+ [TOP_RIGHT_POSITION]: {
5330
+ top: '8%',
5331
+ right: '4%',
5332
+ flexDirection: 'column-reverse'
5333
+ },
5334
+ [TOP_LEFT_POSITION]: {
5335
+ top: '8%',
5336
+ left: '4%',
5337
+ flexDirection: 'column-reverse'
5338
+ },
5339
+ [BOTTOM_RIGHT_POSITION]: {
5340
+ bottom: '8%',
5341
+ right: '4%',
5342
+ flexDirection: 'column'
5343
+ },
5344
+ [BOTTOM_LEFT_POSITION]: {
5345
+ bottom: '8%',
5346
+ left: '4%',
5347
+ flexDirection: 'column'
5348
+ }
5349
+ }
5350
+ },
5351
+ defaultVariants: {
5352
+ position: 'top-right'
5353
+ }
5332
5354
  });
5333
-
5334
- var promiseConstructorDetection = {
5335
- CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
5336
- REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
5337
- SUBCLASSING: SUBCLASSING
5338
- };
5339
-
5340
- var newPromiseCapability$2 = {};
5341
-
5342
- var aCallable$6 = aCallable$a;
5343
-
5344
- var $TypeError$6 = TypeError;
5345
-
5346
- var PromiseCapability = function (C) {
5347
- var resolve, reject;
5348
- this.promise = new C(function ($$resolve, $$reject) {
5349
- if (resolve !== undefined || reject !== undefined) throw $TypeError$6('Bad Promise constructor');
5350
- resolve = $$resolve;
5351
- reject = $$reject;
5352
- });
5353
- this.resolve = aCallable$6(resolve);
5354
- this.reject = aCallable$6(reject);
5355
+ const ToastContainer = ({
5356
+ toasts,
5357
+ position
5358
+ }) => {
5359
+ const {
5360
+ removeToast
5361
+ } = React.useContext(ToastContext);
5362
+ return /*#__PURE__*/React.createElement(Portal, {
5363
+ style: {
5364
+ top: 0,
5365
+ left: 0,
5366
+ position: 'absolute',
5367
+ zIndex: 2147483647
5368
+ },
5369
+ __self: undefined,
5370
+ __source: {
5371
+ fileName: _jsxFileName$U,
5372
+ lineNumber: 43,
5373
+ columnNumber: 5
5374
+ }
5375
+ }, /*#__PURE__*/React.createElement(ToastBox, {
5376
+ position: position,
5377
+ __self: undefined,
5378
+ __source: {
5379
+ fileName: _jsxFileName$U,
5380
+ lineNumber: 44,
5381
+ columnNumber: 7
5382
+ }
5383
+ }, toasts.map((item, index) => {
5384
+ const {
5385
+ preventDuplicate
5386
+ } = item,
5387
+ toast = _objectWithoutPropertiesLoose(item, _excluded$s);
5388
+ return /*#__PURE__*/React.createElement(Toast, _extends({
5389
+ key: preventDuplicate ? toast.id : `${toast.id}-${index}`,
5390
+ onRemove: () => removeToast(toast.id)
5391
+ }, toast, {
5392
+ __self: undefined,
5393
+ __source: {
5394
+ fileName: _jsxFileName$U,
5395
+ lineNumber: 47,
5396
+ columnNumber: 18
5397
+ }
5398
+ }));
5399
+ })));
5355
5400
  };
5356
5401
 
5357
- // `NewPromiseCapability` abstract operation
5358
- // https://tc39.es/ecma262/#sec-newpromisecapability
5359
- newPromiseCapability$2.f = function (C) {
5360
- return new PromiseCapability(C);
5402
+ const getOnLineStatus = () => typeof navigator !== 'undefined' && typeof navigator.onLine === 'boolean' ? navigator.onLine : true;
5403
+ const useNavigatorOnLine = () => {
5404
+ const [status, setStatus] = React__default.useState(getOnLineStatus());
5405
+ const setOnline = () => setStatus(true);
5406
+ const setOffline = () => setStatus(false);
5407
+ React__default.useEffect(() => {
5408
+ window.addEventListener('online', setOnline);
5409
+ window.addEventListener('offline', setOffline);
5410
+ return () => {
5411
+ window.removeEventListener('online', setOnline);
5412
+ window.removeEventListener('offline', setOffline);
5413
+ };
5414
+ }, []);
5415
+ return status;
5361
5416
  };
5362
5417
 
5363
- var $$l = _export;
5364
- var IS_NODE$1 = engineIsNode;
5365
- var global$9 = global$p;
5366
- var call$g = functionCall;
5367
- var defineBuiltIn$7 = defineBuiltIn$b;
5368
- var setPrototypeOf$1 = objectSetPrototypeOf;
5369
- var setToStringTag$2 = setToStringTag$5;
5370
- var setSpecies$1 = setSpecies$2;
5371
- var aCallable$5 = aCallable$a;
5372
- var isCallable$5 = isCallable$p;
5373
- var isObject$7 = isObject$e;
5374
- var anInstance$2 = anInstance$3;
5375
- var speciesConstructor$1 = speciesConstructor$2;
5376
- var task = task$1.set;
5377
- var microtask = microtask_1;
5378
- var hostReportErrors = hostReportErrors$1;
5379
- var perform$2 = perform$3;
5380
- var Queue = queue$1;
5381
- var InternalStateModule$3 = internalState;
5382
- var NativePromiseConstructor$2 = promiseNativeConstructor;
5383
- var PromiseConstructorDetection = promiseConstructorDetection;
5384
- var newPromiseCapabilityModule$3 = newPromiseCapability$2;
5418
+ var classof$5 = classofRaw$2;
5385
5419
 
5386
- var PROMISE = 'Promise';
5387
- var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
5388
- var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
5389
- var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
5390
- var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE);
5391
- var setInternalState$3 = InternalStateModule$3.set;
5392
- var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
5393
- var PromiseConstructor = NativePromiseConstructor$2;
5394
- var PromisePrototype = NativePromisePrototype$1;
5395
- var TypeError$3 = global$9.TypeError;
5396
- var document$1 = global$9.document;
5397
- var process$1 = global$9.process;
5398
- var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
5399
- var newGenericPromiseCapability = newPromiseCapability$1;
5420
+ var engineIsNode = typeof process != 'undefined' && classof$5(process) == 'process';
5400
5421
 
5401
- var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$9.dispatchEvent);
5402
- var UNHANDLED_REJECTION = 'unhandledrejection';
5403
- var REJECTION_HANDLED = 'rejectionhandled';
5404
- var PENDING = 0;
5405
- var FULFILLED = 1;
5406
- var REJECTED = 2;
5407
- var HANDLED = 1;
5408
- var UNHANDLED = 2;
5422
+ var getBuiltIn$3 = getBuiltIn$7;
5423
+ var defineBuiltInAccessor$2 = defineBuiltInAccessor$4;
5424
+ var wellKnownSymbol$a = wellKnownSymbol$l;
5425
+ var DESCRIPTORS$4 = descriptors;
5409
5426
 
5410
- var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
5427
+ var SPECIES$3 = wellKnownSymbol$a('species');
5411
5428
 
5412
- // helpers
5413
- var isThenable = function (it) {
5414
- var then;
5415
- return isObject$7(it) && isCallable$5(then = it.then) ? then : false;
5416
- };
5429
+ var setSpecies$2 = function (CONSTRUCTOR_NAME) {
5430
+ var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME);
5417
5431
 
5418
- var callReaction = function (reaction, state) {
5419
- var value = state.value;
5420
- var ok = state.state == FULFILLED;
5421
- var handler = ok ? reaction.ok : reaction.fail;
5422
- var resolve = reaction.resolve;
5423
- var reject = reaction.reject;
5424
- var domain = reaction.domain;
5425
- var result, then, exited;
5426
- try {
5427
- if (handler) {
5428
- if (!ok) {
5429
- if (state.rejection === UNHANDLED) onHandleUnhandled(state);
5430
- state.rejection = HANDLED;
5431
- }
5432
- if (handler === true) result = value;
5433
- else {
5434
- if (domain) domain.enter();
5435
- result = handler(value); // can throw
5436
- if (domain) {
5437
- domain.exit();
5438
- exited = true;
5439
- }
5440
- }
5441
- if (result === reaction.promise) {
5442
- reject(TypeError$3('Promise-chain cycle'));
5443
- } else if (then = isThenable(result)) {
5444
- call$g(then, result, resolve, reject);
5445
- } else resolve(result);
5446
- } else reject(value);
5447
- } catch (error) {
5448
- if (domain && !exited) domain.exit();
5449
- reject(error);
5432
+ if (DESCRIPTORS$4 && Constructor && !Constructor[SPECIES$3]) {
5433
+ defineBuiltInAccessor$2(Constructor, SPECIES$3, {
5434
+ configurable: true,
5435
+ get: function () { return this; }
5436
+ });
5450
5437
  }
5451
5438
  };
5452
5439
 
5453
- var notify = function (state, isReject) {
5454
- if (state.notified) return;
5455
- state.notified = true;
5456
- microtask(function () {
5457
- var reactions = state.reactions;
5458
- var reaction;
5459
- while (reaction = reactions.get()) {
5460
- callReaction(reaction, state);
5461
- }
5462
- state.notified = false;
5463
- if (isReject && !state.rejection) onUnhandled(state);
5464
- });
5465
- };
5466
-
5467
- var dispatchEvent = function (name, promise, reason) {
5468
- var event, handler;
5469
- if (DISPATCH_EVENT) {
5470
- event = document$1.createEvent('Event');
5471
- event.promise = promise;
5472
- event.reason = reason;
5473
- event.initEvent(name, false, true);
5474
- global$9.dispatchEvent(event);
5475
- } else event = { promise: promise, reason: reason };
5476
- if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$9['on' + name])) handler(event);
5477
- else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
5478
- };
5440
+ var isPrototypeOf$3 = objectIsPrototypeOf;
5479
5441
 
5480
- var onUnhandled = function (state) {
5481
- call$g(task, global$9, function () {
5482
- var promise = state.facade;
5483
- var value = state.value;
5484
- var IS_UNHANDLED = isUnhandled(state);
5485
- var result;
5486
- if (IS_UNHANDLED) {
5487
- result = perform$2(function () {
5488
- if (IS_NODE$1) {
5489
- process$1.emit('unhandledRejection', value, promise);
5490
- } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
5491
- });
5492
- // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
5493
- state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
5494
- if (result.error) throw result.value;
5495
- }
5496
- });
5497
- };
5442
+ var $TypeError$8 = TypeError;
5498
5443
 
5499
- var isUnhandled = function (state) {
5500
- return state.rejection !== HANDLED && !state.parent;
5444
+ var anInstance$3 = function (it, Prototype) {
5445
+ if (isPrototypeOf$3(Prototype, it)) return it;
5446
+ throw $TypeError$8('Incorrect invocation');
5501
5447
  };
5502
5448
 
5503
- var onHandleUnhandled = function (state) {
5504
- call$g(task, global$9, function () {
5505
- var promise = state.facade;
5506
- if (IS_NODE$1) {
5507
- process$1.emit('rejectionHandled', promise);
5508
- } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
5509
- });
5510
- };
5449
+ var uncurryThis$m = functionUncurryThis;
5450
+ var fails$g = fails$t;
5451
+ var isCallable$8 = isCallable$p;
5452
+ var classof$4 = classof$8;
5453
+ var getBuiltIn$2 = getBuiltIn$7;
5454
+ var inspectSource$1 = inspectSource$3;
5511
5455
 
5512
- var bind$4 = function (fn, state, unwrap) {
5513
- return function (value) {
5514
- fn(state, value, unwrap);
5515
- };
5516
- };
5456
+ var noop$1 = function () { /* empty */ };
5457
+ var empty = [];
5458
+ var construct = getBuiltIn$2('Reflect', 'construct');
5459
+ var constructorRegExp = /^\s*(?:class|function)\b/;
5460
+ var exec$6 = uncurryThis$m(constructorRegExp.exec);
5461
+ var INCORRECT_TO_STRING = !constructorRegExp.exec(noop$1);
5517
5462
 
5518
- var internalReject = function (state, value, unwrap) {
5519
- if (state.done) return;
5520
- state.done = true;
5521
- if (unwrap) state = unwrap;
5522
- state.value = value;
5523
- state.state = REJECTED;
5524
- notify(state, true);
5463
+ var isConstructorModern = function isConstructor(argument) {
5464
+ if (!isCallable$8(argument)) return false;
5465
+ try {
5466
+ construct(noop$1, empty, argument);
5467
+ return true;
5468
+ } catch (error) {
5469
+ return false;
5470
+ }
5525
5471
  };
5526
5472
 
5527
- var internalResolve = function (state, value, unwrap) {
5528
- if (state.done) return;
5529
- state.done = true;
5530
- if (unwrap) state = unwrap;
5473
+ var isConstructorLegacy = function isConstructor(argument) {
5474
+ if (!isCallable$8(argument)) return false;
5475
+ switch (classof$4(argument)) {
5476
+ case 'AsyncFunction':
5477
+ case 'GeneratorFunction':
5478
+ case 'AsyncGeneratorFunction': return false;
5479
+ }
5531
5480
  try {
5532
- if (state.facade === value) throw TypeError$3("Promise can't be resolved itself");
5533
- var then = isThenable(value);
5534
- if (then) {
5535
- microtask(function () {
5536
- var wrapper = { done: false };
5537
- try {
5538
- call$g(then, value,
5539
- bind$4(internalResolve, wrapper, state),
5540
- bind$4(internalReject, wrapper, state)
5541
- );
5542
- } catch (error) {
5543
- internalReject(wrapper, error, state);
5544
- }
5545
- });
5546
- } else {
5547
- state.value = value;
5548
- state.state = FULFILLED;
5549
- notify(state, false);
5550
- }
5481
+ // we can't check .prototype since constructors produced by .bind haven't it
5482
+ // `Function#toString` throws on some built-it function in some legacy engines
5483
+ // (for example, `DOMQuad` and similar in FF41-)
5484
+ return INCORRECT_TO_STRING || !!exec$6(constructorRegExp, inspectSource$1(argument));
5551
5485
  } catch (error) {
5552
- internalReject({ done: false }, error, state);
5486
+ return true;
5553
5487
  }
5554
5488
  };
5555
5489
 
5556
- // constructor polyfill
5557
- if (FORCED_PROMISE_CONSTRUCTOR$4) {
5558
- // 25.4.3.1 Promise(executor)
5559
- PromiseConstructor = function Promise(executor) {
5560
- anInstance$2(this, PromisePrototype);
5561
- aCallable$5(executor);
5562
- call$g(Internal, this);
5563
- var state = getInternalPromiseState(this);
5564
- try {
5565
- executor(bind$4(internalResolve, state), bind$4(internalReject, state));
5566
- } catch (error) {
5567
- internalReject(state, error);
5568
- }
5569
- };
5490
+ isConstructorLegacy.sham = true;
5570
5491
 
5571
- PromisePrototype = PromiseConstructor.prototype;
5492
+ // `IsConstructor` abstract operation
5493
+ // https://tc39.es/ecma262/#sec-isconstructor
5494
+ var isConstructor$2 = !construct || fails$g(function () {
5495
+ var called;
5496
+ return isConstructorModern(isConstructorModern.call)
5497
+ || !isConstructorModern(Object)
5498
+ || !isConstructorModern(function () { called = true; })
5499
+ || called;
5500
+ }) ? isConstructorLegacy : isConstructorModern;
5572
5501
 
5573
- // eslint-disable-next-line no-unused-vars -- required for `.length`
5574
- Internal = function Promise(executor) {
5575
- setInternalState$3(this, {
5576
- type: PROMISE,
5577
- done: false,
5578
- notified: false,
5579
- parent: false,
5580
- reactions: new Queue(),
5581
- rejection: false,
5582
- state: PENDING,
5583
- value: undefined
5584
- });
5585
- };
5502
+ var isConstructor$1 = isConstructor$2;
5503
+ var tryToString$3 = tryToString$5;
5586
5504
 
5587
- // `Promise.prototype.then` method
5588
- // https://tc39.es/ecma262/#sec-promise.prototype.then
5589
- Internal.prototype = defineBuiltIn$7(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
5590
- var state = getInternalPromiseState(this);
5591
- var reaction = newPromiseCapability$1(speciesConstructor$1(this, PromiseConstructor));
5592
- state.parent = true;
5593
- reaction.ok = isCallable$5(onFulfilled) ? onFulfilled : true;
5594
- reaction.fail = isCallable$5(onRejected) && onRejected;
5595
- reaction.domain = IS_NODE$1 ? process$1.domain : undefined;
5596
- if (state.state == PENDING) state.reactions.add(reaction);
5597
- else microtask(function () {
5598
- callReaction(reaction, state);
5599
- });
5600
- return reaction.promise;
5601
- });
5505
+ var $TypeError$7 = TypeError;
5602
5506
 
5603
- OwnPromiseCapability = function () {
5604
- var promise = new Internal();
5605
- var state = getInternalPromiseState(promise);
5606
- this.promise = promise;
5607
- this.resolve = bind$4(internalResolve, state);
5608
- this.reject = bind$4(internalReject, state);
5609
- };
5507
+ // `Assert: IsConstructor(argument) is true`
5508
+ var aConstructor$1 = function (argument) {
5509
+ if (isConstructor$1(argument)) return argument;
5510
+ throw $TypeError$7(tryToString$3(argument) + ' is not a constructor');
5511
+ };
5610
5512
 
5611
- newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
5612
- return C === PromiseConstructor || C === PromiseWrapper
5613
- ? new OwnPromiseCapability(C)
5614
- : newGenericPromiseCapability(C);
5615
- };
5513
+ var anObject$d = anObject$j;
5514
+ var aConstructor = aConstructor$1;
5515
+ var isNullOrUndefined$5 = isNullOrUndefined$8;
5516
+ var wellKnownSymbol$9 = wellKnownSymbol$l;
5616
5517
 
5617
- if (isCallable$5(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
5618
- nativeThen = NativePromisePrototype$1.then;
5518
+ var SPECIES$2 = wellKnownSymbol$9('species');
5619
5519
 
5620
- if (!NATIVE_PROMISE_SUBCLASSING) {
5621
- // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
5622
- defineBuiltIn$7(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
5623
- var that = this;
5624
- return new PromiseConstructor(function (resolve, reject) {
5625
- call$g(nativeThen, that, resolve, reject);
5626
- }).then(onFulfilled, onRejected);
5627
- // https://github.com/zloirock/core-js/issues/640
5628
- }, { unsafe: true });
5629
- }
5520
+ // `SpeciesConstructor` abstract operation
5521
+ // https://tc39.es/ecma262/#sec-speciesconstructor
5522
+ var speciesConstructor$2 = function (O, defaultConstructor) {
5523
+ var C = anObject$d(O).constructor;
5524
+ var S;
5525
+ return C === undefined || isNullOrUndefined$5(S = anObject$d(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S);
5526
+ };
5630
5527
 
5631
- // make `.constructor === Promise` work for native promise-based APIs
5632
- try {
5633
- delete NativePromisePrototype$1.constructor;
5634
- } catch (error) { /* empty */ }
5528
+ var NATIVE_BIND$1 = functionBindNative;
5635
5529
 
5636
- // make `instanceof Promise` work for native promise-based APIs
5637
- if (setPrototypeOf$1) {
5638
- setPrototypeOf$1(NativePromisePrototype$1, PromisePrototype);
5639
- }
5640
- }
5641
- }
5530
+ var FunctionPrototype = Function.prototype;
5531
+ var apply$3 = FunctionPrototype.apply;
5532
+ var call$h = FunctionPrototype.call;
5642
5533
 
5643
- $$l({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
5644
- Promise: PromiseConstructor
5534
+ // eslint-disable-next-line es/no-reflect -- safe
5535
+ var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$h.bind(apply$3) : function () {
5536
+ return call$h.apply(apply$3, arguments);
5645
5537
  });
5646
5538
 
5647
- setToStringTag$2(PromiseConstructor, PROMISE, false);
5648
- setSpecies$1(PROMISE);
5649
-
5650
- var wellKnownSymbol$9 = wellKnownSymbol$l;
5651
- var Iterators$1 = iterators;
5652
-
5653
- var ITERATOR$6 = wellKnownSymbol$9('iterator');
5654
- var ArrayPrototype = Array.prototype;
5539
+ var classofRaw = classofRaw$2;
5540
+ var uncurryThis$l = functionUncurryThis;
5655
5541
 
5656
- // check on default Array iterator
5657
- var isArrayIteratorMethod$2 = function (it) {
5658
- return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$6] === it);
5542
+ var functionUncurryThisClause = function (fn) {
5543
+ // Nashorn bug:
5544
+ // https://github.com/zloirock/core-js/issues/1128
5545
+ // https://github.com/zloirock/core-js/issues/1130
5546
+ if (classofRaw(fn) === 'Function') return uncurryThis$l(fn);
5659
5547
  };
5660
5548
 
5661
- var classof$4 = classof$8;
5662
- var getMethod$5 = getMethod$7;
5663
- var isNullOrUndefined$4 = isNullOrUndefined$8;
5664
- var Iterators = iterators;
5665
- var wellKnownSymbol$8 = wellKnownSymbol$l;
5549
+ var uncurryThis$k = functionUncurryThisClause;
5550
+ var aCallable$7 = aCallable$a;
5551
+ var NATIVE_BIND = functionBindNative;
5666
5552
 
5667
- var ITERATOR$5 = wellKnownSymbol$8('iterator');
5553
+ var bind$7 = uncurryThis$k(uncurryThis$k.bind);
5668
5554
 
5669
- var getIteratorMethod$4 = function (it) {
5670
- if (!isNullOrUndefined$4(it)) return getMethod$5(it, ITERATOR$5)
5671
- || getMethod$5(it, '@@iterator')
5672
- || Iterators[classof$4(it)];
5555
+ // optional / simple context binding
5556
+ var functionBindContext = function (fn, that) {
5557
+ aCallable$7(fn);
5558
+ return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) {
5559
+ return fn.apply(that, arguments);
5560
+ };
5673
5561
  };
5674
5562
 
5675
- var call$f = functionCall;
5676
- var aCallable$4 = aCallable$a;
5677
- var anObject$c = anObject$j;
5678
- var tryToString$2 = tryToString$5;
5679
- var getIteratorMethod$3 = getIteratorMethod$4;
5563
+ var uncurryThis$j = functionUncurryThis;
5680
5564
 
5681
- var $TypeError$5 = TypeError;
5565
+ var arraySlice$4 = uncurryThis$j([].slice);
5682
5566
 
5683
- var getIterator$3 = function (argument, usingIterator) {
5684
- var iteratorMethod = arguments.length < 2 ? getIteratorMethod$3(argument) : usingIterator;
5685
- if (aCallable$4(iteratorMethod)) return anObject$c(call$f(iteratorMethod, argument));
5686
- throw $TypeError$5(tryToString$2(argument) + ' is not iterable');
5567
+ var $TypeError$6 = TypeError;
5568
+
5569
+ var validateArgumentsLength$3 = function (passed, required) {
5570
+ if (passed < required) throw $TypeError$6('Not enough arguments');
5571
+ return passed;
5687
5572
  };
5688
5573
 
5689
- var call$e = functionCall;
5690
- var anObject$b = anObject$j;
5691
- var getMethod$4 = getMethod$7;
5574
+ var userAgent$4 = engineUserAgent;
5692
5575
 
5693
- var iteratorClose$2 = function (iterator, kind, value) {
5694
- var innerResult, innerError;
5695
- anObject$b(iterator);
5696
- try {
5697
- innerResult = getMethod$4(iterator, 'return');
5698
- if (!innerResult) {
5699
- if (kind === 'throw') throw value;
5700
- return value;
5701
- }
5702
- innerResult = call$e(innerResult, iterator);
5703
- } catch (error) {
5704
- innerError = true;
5705
- innerResult = error;
5706
- }
5707
- if (kind === 'throw') throw value;
5708
- if (innerError) throw innerResult;
5709
- anObject$b(innerResult);
5710
- return value;
5711
- };
5576
+ // eslint-disable-next-line redos/no-vulnerable -- safe
5577
+ var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4);
5578
+
5579
+ var global$d = global$p;
5580
+ var apply$2 = functionApply;
5581
+ var bind$6 = functionBindContext;
5582
+ var isCallable$7 = isCallable$p;
5583
+ var hasOwn$4 = hasOwnProperty_1;
5584
+ var fails$f = fails$t;
5585
+ var html = html$2;
5586
+ var arraySlice$3 = arraySlice$4;
5587
+ var createElement = documentCreateElement$2;
5588
+ var validateArgumentsLength$2 = validateArgumentsLength$3;
5589
+ var IS_IOS$1 = engineIsIos;
5590
+ var IS_NODE$4 = engineIsNode;
5591
+
5592
+ var set = global$d.setImmediate;
5593
+ var clear = global$d.clearImmediate;
5594
+ var process$3 = global$d.process;
5595
+ var Dispatch = global$d.Dispatch;
5596
+ var Function$1 = global$d.Function;
5597
+ var MessageChannel = global$d.MessageChannel;
5598
+ var String$1 = global$d.String;
5599
+ var counter = 0;
5600
+ var queue$2 = {};
5601
+ var ONREADYSTATECHANGE = 'onreadystatechange';
5602
+ var $location, defer, channel, port;
5712
5603
 
5713
- var bind$3 = functionBindContext;
5714
- var call$d = functionCall;
5715
- var anObject$a = anObject$j;
5716
- var tryToString$1 = tryToString$5;
5717
- var isArrayIteratorMethod$1 = isArrayIteratorMethod$2;
5718
- var lengthOfArrayLike$4 = lengthOfArrayLike$6;
5719
- var isPrototypeOf$2 = objectIsPrototypeOf;
5720
- var getIterator$2 = getIterator$3;
5721
- var getIteratorMethod$2 = getIteratorMethod$4;
5722
- var iteratorClose$1 = iteratorClose$2;
5604
+ fails$f(function () {
5605
+ // Deno throws a ReferenceError on `location` access without `--location` flag
5606
+ $location = global$d.location;
5607
+ });
5723
5608
 
5724
- var $TypeError$4 = TypeError;
5609
+ var run = function (id) {
5610
+ if (hasOwn$4(queue$2, id)) {
5611
+ var fn = queue$2[id];
5612
+ delete queue$2[id];
5613
+ fn();
5614
+ }
5615
+ };
5725
5616
 
5726
- var Result = function (stopped, result) {
5727
- this.stopped = stopped;
5728
- this.result = result;
5617
+ var runner = function (id) {
5618
+ return function () {
5619
+ run(id);
5620
+ };
5729
5621
  };
5730
5622
 
5731
- var ResultPrototype = Result.prototype;
5623
+ var eventListener = function (event) {
5624
+ run(event.data);
5625
+ };
5732
5626
 
5733
- var iterate$2 = function (iterable, unboundFunction, options) {
5734
- var that = options && options.that;
5735
- var AS_ENTRIES = !!(options && options.AS_ENTRIES);
5736
- var IS_RECORD = !!(options && options.IS_RECORD);
5737
- var IS_ITERATOR = !!(options && options.IS_ITERATOR);
5738
- var INTERRUPTED = !!(options && options.INTERRUPTED);
5739
- var fn = bind$3(unboundFunction, that);
5740
- var iterator, iterFn, index, length, result, next, step;
5627
+ var globalPostMessageDefer = function (id) {
5628
+ // old engines have not location.origin
5629
+ global$d.postMessage(String$1(id), $location.protocol + '//' + $location.host);
5630
+ };
5741
5631
 
5742
- var stop = function (condition) {
5743
- if (iterator) iteratorClose$1(iterator, 'normal', condition);
5744
- return new Result(true, condition);
5632
+ // Node.js 0.9+ & IE10+ has setImmediate, otherwise:
5633
+ if (!set || !clear) {
5634
+ set = function setImmediate(handler) {
5635
+ validateArgumentsLength$2(arguments.length, 1);
5636
+ var fn = isCallable$7(handler) ? handler : Function$1(handler);
5637
+ var args = arraySlice$3(arguments, 1);
5638
+ queue$2[++counter] = function () {
5639
+ apply$2(fn, undefined, args);
5640
+ };
5641
+ defer(counter);
5642
+ return counter;
5745
5643
  };
5746
-
5747
- var callFn = function (value) {
5748
- if (AS_ENTRIES) {
5749
- anObject$a(value);
5750
- return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
5751
- } return INTERRUPTED ? fn(value, stop) : fn(value);
5644
+ clear = function clearImmediate(id) {
5645
+ delete queue$2[id];
5752
5646
  };
5753
-
5754
- if (IS_RECORD) {
5755
- iterator = iterable.iterator;
5756
- } else if (IS_ITERATOR) {
5757
- iterator = iterable;
5647
+ // Node.js 0.8-
5648
+ if (IS_NODE$4) {
5649
+ defer = function (id) {
5650
+ process$3.nextTick(runner(id));
5651
+ };
5652
+ // Sphere (JS game engine) Dispatch API
5653
+ } else if (Dispatch && Dispatch.now) {
5654
+ defer = function (id) {
5655
+ Dispatch.now(runner(id));
5656
+ };
5657
+ // Browsers with MessageChannel, includes WebWorkers
5658
+ // except iOS - https://github.com/zloirock/core-js/issues/624
5659
+ } else if (MessageChannel && !IS_IOS$1) {
5660
+ channel = new MessageChannel();
5661
+ port = channel.port2;
5662
+ channel.port1.onmessage = eventListener;
5663
+ defer = bind$6(port.postMessage, port);
5664
+ // Browsers with postMessage, skip WebWorkers
5665
+ // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
5666
+ } else if (
5667
+ global$d.addEventListener &&
5668
+ isCallable$7(global$d.postMessage) &&
5669
+ !global$d.importScripts &&
5670
+ $location && $location.protocol !== 'file:' &&
5671
+ !fails$f(globalPostMessageDefer)
5672
+ ) {
5673
+ defer = globalPostMessageDefer;
5674
+ global$d.addEventListener('message', eventListener, false);
5675
+ // IE8-
5676
+ } else if (ONREADYSTATECHANGE in createElement('script')) {
5677
+ defer = function (id) {
5678
+ html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
5679
+ html.removeChild(this);
5680
+ run(id);
5681
+ };
5682
+ };
5683
+ // Rest old browsers
5758
5684
  } else {
5759
- iterFn = getIteratorMethod$2(iterable);
5760
- if (!iterFn) throw $TypeError$4(tryToString$1(iterable) + ' is not iterable');
5761
- // optimisation for array iterators
5762
- if (isArrayIteratorMethod$1(iterFn)) {
5763
- for (index = 0, length = lengthOfArrayLike$4(iterable); length > index; index++) {
5764
- result = callFn(iterable[index]);
5765
- if (result && isPrototypeOf$2(ResultPrototype, result)) return result;
5766
- } return new Result(false);
5767
- }
5768
- iterator = getIterator$2(iterable, iterFn);
5685
+ defer = function (id) {
5686
+ setTimeout(runner(id), 0);
5687
+ };
5769
5688
  }
5689
+ }
5770
5690
 
5771
- next = IS_RECORD ? iterable.next : iterator.next;
5772
- while (!(step = call$d(next, iterator)).done) {
5773
- try {
5774
- result = callFn(step.value);
5775
- } catch (error) {
5776
- iteratorClose$1(iterator, 'throw', error);
5777
- }
5778
- if (typeof result == 'object' && result && isPrototypeOf$2(ResultPrototype, result)) return result;
5779
- } return new Result(false);
5691
+ var task$1 = {
5692
+ set: set,
5693
+ clear: clear
5780
5694
  };
5781
5695
 
5782
- var wellKnownSymbol$7 = wellKnownSymbol$l;
5783
-
5784
- var ITERATOR$4 = wellKnownSymbol$7('iterator');
5785
- var SAFE_CLOSING = false;
5696
+ var Queue$2 = function () {
5697
+ this.head = null;
5698
+ this.tail = null;
5699
+ };
5786
5700
 
5787
- try {
5788
- var called = 0;
5789
- var iteratorWithReturn = {
5790
- next: function () {
5791
- return { done: !!called++ };
5792
- },
5793
- 'return': function () {
5794
- SAFE_CLOSING = true;
5701
+ Queue$2.prototype = {
5702
+ add: function (item) {
5703
+ var entry = { item: item, next: null };
5704
+ var tail = this.tail;
5705
+ if (tail) tail.next = entry;
5706
+ else this.head = entry;
5707
+ this.tail = entry;
5708
+ },
5709
+ get: function () {
5710
+ var entry = this.head;
5711
+ if (entry) {
5712
+ var next = this.head = entry.next;
5713
+ if (next === null) this.tail = null;
5714
+ return entry.item;
5795
5715
  }
5796
- };
5797
- iteratorWithReturn[ITERATOR$4] = function () {
5798
- return this;
5799
- };
5800
- // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
5801
- Array.from(iteratorWithReturn, function () { throw 2; });
5802
- } catch (error) { /* empty */ }
5803
-
5804
- var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
5805
- if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
5806
- var ITERATION_SUPPORT = false;
5807
- try {
5808
- var object = {};
5809
- object[ITERATOR$4] = function () {
5810
- return {
5811
- next: function () {
5812
- return { done: ITERATION_SUPPORT = true };
5813
- }
5814
- };
5815
- };
5816
- exec(object);
5817
- } catch (error) { /* empty */ }
5818
- return ITERATION_SUPPORT;
5716
+ }
5819
5717
  };
5820
5718
 
5821
- var NativePromiseConstructor$1 = promiseNativeConstructor;
5822
- var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
5823
- var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
5719
+ var queue$1 = Queue$2;
5824
5720
 
5825
- var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) {
5826
- NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ });
5827
- });
5721
+ var userAgent$3 = engineUserAgent;
5828
5722
 
5829
- var $$k = _export;
5830
- var call$c = functionCall;
5831
- var aCallable$3 = aCallable$a;
5832
- var newPromiseCapabilityModule$2 = newPromiseCapability$2;
5833
- var perform$1 = perform$3;
5834
- var iterate$1 = iterate$2;
5835
- var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
5723
+ var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined';
5836
5724
 
5837
- // `Promise.all` method
5838
- // https://tc39.es/ecma262/#sec-promise.all
5839
- $$k({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
5840
- all: function all(iterable) {
5841
- var C = this;
5842
- var capability = newPromiseCapabilityModule$2.f(C);
5843
- var resolve = capability.resolve;
5844
- var reject = capability.reject;
5845
- var result = perform$1(function () {
5846
- var $promiseResolve = aCallable$3(C.resolve);
5847
- var values = [];
5848
- var counter = 0;
5849
- var remaining = 1;
5850
- iterate$1(iterable, function (promise) {
5851
- var index = counter++;
5852
- var alreadyCalled = false;
5853
- remaining++;
5854
- call$c($promiseResolve, C, promise).then(function (value) {
5855
- if (alreadyCalled) return;
5856
- alreadyCalled = true;
5857
- values[index] = value;
5858
- --remaining || resolve(values);
5859
- }, reject);
5860
- });
5861
- --remaining || resolve(values);
5862
- });
5863
- if (result.error) reject(result.value);
5864
- return capability.promise;
5865
- }
5866
- });
5725
+ var userAgent$2 = engineUserAgent;
5726
+
5727
+ var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2);
5728
+
5729
+ var global$c = global$p;
5730
+ var bind$5 = functionBindContext;
5731
+ var getOwnPropertyDescriptor$3 = objectGetOwnPropertyDescriptor.f;
5732
+ var macrotask = task$1.set;
5733
+ var Queue$1 = queue$1;
5734
+ var IS_IOS = engineIsIos;
5735
+ var IS_IOS_PEBBLE = engineIsIosPebble;
5736
+ var IS_WEBOS_WEBKIT = engineIsWebosWebkit;
5737
+ var IS_NODE$3 = engineIsNode;
5738
+
5739
+ var MutationObserver = global$c.MutationObserver || global$c.WebKitMutationObserver;
5740
+ var document$2 = global$c.document;
5741
+ var process$2 = global$c.process;
5742
+ var Promise$1 = global$c.Promise;
5743
+ // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
5744
+ var queueMicrotaskDescriptor = getOwnPropertyDescriptor$3(global$c, 'queueMicrotask');
5745
+ var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
5746
+ var notify$1, toggle, node, promise, then;
5867
5747
 
5868
- var $$j = _export;
5869
- var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
5870
- var NativePromiseConstructor = promiseNativeConstructor;
5871
- var getBuiltIn$1 = getBuiltIn$7;
5872
- var isCallable$4 = isCallable$p;
5873
- var defineBuiltIn$6 = defineBuiltIn$b;
5748
+ // modern engines have queueMicrotask method
5749
+ if (!microtask$1) {
5750
+ var queue = new Queue$1();
5874
5751
 
5875
- var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
5752
+ var flush = function () {
5753
+ var parent, fn;
5754
+ if (IS_NODE$3 && (parent = process$2.domain)) parent.exit();
5755
+ while (fn = queue.get()) try {
5756
+ fn();
5757
+ } catch (error) {
5758
+ if (queue.head) notify$1();
5759
+ throw error;
5760
+ }
5761
+ if (parent) parent.enter();
5762
+ };
5876
5763
 
5877
- // `Promise.prototype.catch` method
5878
- // https://tc39.es/ecma262/#sec-promise.prototype.catch
5879
- $$j({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
5880
- 'catch': function (onRejected) {
5881
- return this.then(undefined, onRejected);
5764
+ // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
5765
+ // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
5766
+ if (!IS_IOS && !IS_NODE$3 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) {
5767
+ toggle = true;
5768
+ node = document$2.createTextNode('');
5769
+ new MutationObserver(flush).observe(node, { characterData: true });
5770
+ notify$1 = function () {
5771
+ node.data = toggle = !toggle;
5772
+ };
5773
+ // environments with maybe non-completely correct, but existent Promise
5774
+ } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) {
5775
+ // Promise.resolve without an argument throws an error in LG WebOS 2
5776
+ promise = Promise$1.resolve(undefined);
5777
+ // workaround of WebKit ~ iOS Safari 10.1 bug
5778
+ promise.constructor = Promise$1;
5779
+ then = bind$5(promise.then, promise);
5780
+ notify$1 = function () {
5781
+ then(flush);
5782
+ };
5783
+ // Node.js without promises
5784
+ } else if (IS_NODE$3) {
5785
+ notify$1 = function () {
5786
+ process$2.nextTick(flush);
5787
+ };
5788
+ // for other environments - macrotask based on:
5789
+ // - setImmediate
5790
+ // - MessageChannel
5791
+ // - window.postMessage
5792
+ // - onreadystatechange
5793
+ // - setTimeout
5794
+ } else {
5795
+ // `webpack` dev server bug on IE global methods - use bind(fn, global)
5796
+ macrotask = bind$5(macrotask, global$c);
5797
+ notify$1 = function () {
5798
+ macrotask(flush);
5799
+ };
5882
5800
  }
5883
- });
5884
5801
 
5885
- // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
5886
- if (isCallable$4(NativePromiseConstructor)) {
5887
- var method = getBuiltIn$1('Promise').prototype['catch'];
5888
- if (NativePromisePrototype['catch'] !== method) {
5889
- defineBuiltIn$6(NativePromisePrototype, 'catch', method, { unsafe: true });
5890
- }
5802
+ microtask$1 = function (fn) {
5803
+ if (!queue.head) notify$1();
5804
+ queue.add(fn);
5805
+ };
5891
5806
  }
5892
5807
 
5893
- var $$i = _export;
5894
- var call$b = functionCall;
5895
- var aCallable$2 = aCallable$a;
5896
- var newPromiseCapabilityModule$1 = newPromiseCapability$2;
5897
- var perform = perform$3;
5898
- var iterate = iterate$2;
5899
- var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
5900
-
5901
- // `Promise.race` method
5902
- // https://tc39.es/ecma262/#sec-promise.race
5903
- $$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
5904
- race: function race(iterable) {
5905
- var C = this;
5906
- var capability = newPromiseCapabilityModule$1.f(C);
5907
- var reject = capability.reject;
5908
- var result = perform(function () {
5909
- var $promiseResolve = aCallable$2(C.resolve);
5910
- iterate(iterable, function (promise) {
5911
- call$b($promiseResolve, C, promise).then(capability.resolve, reject);
5912
- });
5913
- });
5914
- if (result.error) reject(result.value);
5915
- return capability.promise;
5916
- }
5917
- });
5808
+ var microtask_1 = microtask$1;
5918
5809
 
5919
- var $$h = _export;
5920
- var call$a = functionCall;
5921
- var newPromiseCapabilityModule = newPromiseCapability$2;
5922
- var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
5810
+ var hostReportErrors$1 = function (a, b) {
5811
+ try {
5812
+ // eslint-disable-next-line no-console -- safe
5813
+ arguments.length == 1 ? console.error(a) : console.error(a, b);
5814
+ } catch (error) { /* empty */ }
5815
+ };
5923
5816
 
5924
- // `Promise.reject` method
5925
- // https://tc39.es/ecma262/#sec-promise.reject
5926
- $$h({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
5927
- reject: function reject(r) {
5928
- var capability = newPromiseCapabilityModule.f(this);
5929
- call$a(capability.reject, undefined, r);
5930
- return capability.promise;
5817
+ var perform$3 = function (exec) {
5818
+ try {
5819
+ return { error: false, value: exec() };
5820
+ } catch (error) {
5821
+ return { error: true, value: error };
5931
5822
  }
5932
- });
5933
-
5934
- var anObject$9 = anObject$j;
5935
- var isObject$6 = isObject$e;
5936
- var newPromiseCapability = newPromiseCapability$2;
5937
-
5938
- var promiseResolve$1 = function (C, x) {
5939
- anObject$9(C);
5940
- if (isObject$6(x) && x.constructor === C) return x;
5941
- var promiseCapability = newPromiseCapability.f(C);
5942
- var resolve = promiseCapability.resolve;
5943
- resolve(x);
5944
- return promiseCapability.promise;
5945
5823
  };
5946
5824
 
5947
- var $$g = _export;
5948
- var getBuiltIn = getBuiltIn$7;
5949
- var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
5950
- var promiseResolve = promiseResolve$1;
5825
+ var global$b = global$p;
5951
5826
 
5952
- getBuiltIn('Promise');
5827
+ var promiseNativeConstructor = global$b.Promise;
5953
5828
 
5954
- // `Promise.resolve` method
5955
- // https://tc39.es/ecma262/#sec-promise.resolve
5956
- $$g({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
5957
- resolve: function resolve(x) {
5958
- return promiseResolve(this, x);
5959
- }
5960
- });
5829
+ /* global Deno -- Deno case */
5961
5830
 
5962
- var $$f = _export;
5963
- var $includes = arrayIncludes.includes;
5964
- var fails$f = fails$t;
5965
- var addToUnscopables = addToUnscopables$2;
5831
+ var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';
5966
5832
 
5967
- // FF99+ bug
5968
- var BROKEN_ON_SPARSE = fails$f(function () {
5969
- // eslint-disable-next-line es/no-array-prototype-includes -- detection
5970
- return !Array(1).includes();
5971
- });
5833
+ var IS_DENO$1 = engineIsDeno;
5834
+ var IS_NODE$2 = engineIsNode;
5972
5835
 
5973
- // `Array.prototype.includes` method
5974
- // https://tc39.es/ecma262/#sec-array.prototype.includes
5975
- $$f({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {
5976
- includes: function includes(el /* , fromIndex = 0 */) {
5977
- return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
5978
- }
5979
- });
5836
+ var engineIsBrowser = !IS_DENO$1 && !IS_NODE$2
5837
+ && typeof window == 'object'
5838
+ && typeof document == 'object';
5980
5839
 
5981
- // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
5982
- addToUnscopables('includes');
5840
+ var global$a = global$p;
5841
+ var NativePromiseConstructor$3 = promiseNativeConstructor;
5842
+ var isCallable$6 = isCallable$p;
5843
+ var isForced$1 = isForced_1;
5844
+ var inspectSource = inspectSource$3;
5845
+ var wellKnownSymbol$8 = wellKnownSymbol$l;
5846
+ var IS_BROWSER = engineIsBrowser;
5847
+ var IS_DENO = engineIsDeno;
5848
+ var V8_VERSION = engineV8Version;
5983
5849
 
5984
- var isObject$5 = isObject$e;
5985
- var classof$3 = classofRaw$2;
5986
- var wellKnownSymbol$6 = wellKnownSymbol$l;
5850
+ NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype;
5851
+ var SPECIES$1 = wellKnownSymbol$8('species');
5852
+ var SUBCLASSING = false;
5853
+ var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$6(global$a.PromiseRejectionEvent);
5987
5854
 
5988
- var MATCH$2 = wellKnownSymbol$6('match');
5855
+ var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () {
5856
+ var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3);
5857
+ var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3);
5858
+ // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
5859
+ // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
5860
+ // We can't detect it synchronously, so just check versions
5861
+ if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
5862
+ // We can't use @@species feature detection in V8 since it causes
5863
+ // deoptimization and performance degradation
5864
+ // https://github.com/zloirock/core-js/issues/679
5865
+ if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {
5866
+ // Detect correctness of subclassing with @@species support
5867
+ var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); });
5868
+ var FakePromise = function (exec) {
5869
+ exec(function () { /* empty */ }, function () { /* empty */ });
5870
+ };
5871
+ var constructor = promise.constructor = {};
5872
+ constructor[SPECIES$1] = FakePromise;
5873
+ SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
5874
+ if (!SUBCLASSING) return true;
5875
+ // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
5876
+ } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1;
5877
+ });
5989
5878
 
5990
- // `IsRegExp` abstract operation
5991
- // https://tc39.es/ecma262/#sec-isregexp
5992
- var isRegexp = function (it) {
5993
- var isRegExp;
5994
- return isObject$5(it) && ((isRegExp = it[MATCH$2]) !== undefined ? !!isRegExp : classof$3(it) == 'RegExp');
5879
+ var promiseConstructorDetection = {
5880
+ CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5,
5881
+ REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1,
5882
+ SUBCLASSING: SUBCLASSING
5995
5883
  };
5996
5884
 
5997
- var isRegExp$2 = isRegexp;
5998
-
5999
- var $TypeError$3 = TypeError;
5885
+ var newPromiseCapability$2 = {};
6000
5886
 
6001
- var notARegexp = function (it) {
6002
- if (isRegExp$2(it)) {
6003
- throw $TypeError$3("The method doesn't accept regular expressions");
6004
- } return it;
6005
- };
5887
+ var aCallable$6 = aCallable$a;
6006
5888
 
6007
- var wellKnownSymbol$5 = wellKnownSymbol$l;
5889
+ var $TypeError$5 = TypeError;
6008
5890
 
6009
- var MATCH$1 = wellKnownSymbol$5('match');
5891
+ var PromiseCapability = function (C) {
5892
+ var resolve, reject;
5893
+ this.promise = new C(function ($$resolve, $$reject) {
5894
+ if (resolve !== undefined || reject !== undefined) throw $TypeError$5('Bad Promise constructor');
5895
+ resolve = $$resolve;
5896
+ reject = $$reject;
5897
+ });
5898
+ this.resolve = aCallable$6(resolve);
5899
+ this.reject = aCallable$6(reject);
5900
+ };
6010
5901
 
6011
- var correctIsRegexpLogic = function (METHOD_NAME) {
6012
- var regexp = /./;
6013
- try {
6014
- '/./'[METHOD_NAME](regexp);
6015
- } catch (error1) {
6016
- try {
6017
- regexp[MATCH$1] = false;
6018
- return '/./'[METHOD_NAME](regexp);
6019
- } catch (error2) { /* empty */ }
6020
- } return false;
5902
+ // `NewPromiseCapability` abstract operation
5903
+ // https://tc39.es/ecma262/#sec-newpromisecapability
5904
+ newPromiseCapability$2.f = function (C) {
5905
+ return new PromiseCapability(C);
6021
5906
  };
6022
5907
 
6023
- var $$e = _export;
6024
- var uncurryThis$j = functionUncurryThis;
6025
- var notARegExp$2 = notARegexp;
6026
- var requireObjectCoercible$9 = requireObjectCoercible$c;
6027
- var toString$h = toString$j;
6028
- var correctIsRegExpLogic$2 = correctIsRegexpLogic;
5908
+ var $$j = _export;
5909
+ var IS_NODE$1 = engineIsNode;
5910
+ var global$9 = global$p;
5911
+ var call$g = functionCall;
5912
+ var defineBuiltIn$7 = defineBuiltIn$b;
5913
+ var setPrototypeOf$1 = objectSetPrototypeOf;
5914
+ var setToStringTag$2 = setToStringTag$5;
5915
+ var setSpecies$1 = setSpecies$2;
5916
+ var aCallable$5 = aCallable$a;
5917
+ var isCallable$5 = isCallable$p;
5918
+ var isObject$6 = isObject$e;
5919
+ var anInstance$2 = anInstance$3;
5920
+ var speciesConstructor$1 = speciesConstructor$2;
5921
+ var task = task$1.set;
5922
+ var microtask = microtask_1;
5923
+ var hostReportErrors = hostReportErrors$1;
5924
+ var perform$2 = perform$3;
5925
+ var Queue = queue$1;
5926
+ var InternalStateModule$3 = internalState;
5927
+ var NativePromiseConstructor$2 = promiseNativeConstructor;
5928
+ var PromiseConstructorDetection = promiseConstructorDetection;
5929
+ var newPromiseCapabilityModule$3 = newPromiseCapability$2;
5930
+
5931
+ var PROMISE = 'Promise';
5932
+ var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR;
5933
+ var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;
5934
+ var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;
5935
+ var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE);
5936
+ var setInternalState$3 = InternalStateModule$3.set;
5937
+ var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype;
5938
+ var PromiseConstructor = NativePromiseConstructor$2;
5939
+ var PromisePrototype = NativePromisePrototype$1;
5940
+ var TypeError$3 = global$9.TypeError;
5941
+ var document$1 = global$9.document;
5942
+ var process$1 = global$9.process;
5943
+ var newPromiseCapability$1 = newPromiseCapabilityModule$3.f;
5944
+ var newGenericPromiseCapability = newPromiseCapability$1;
6029
5945
 
6030
- var stringIndexOf$2 = uncurryThis$j(''.indexOf);
5946
+ var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$9.dispatchEvent);
5947
+ var UNHANDLED_REJECTION = 'unhandledrejection';
5948
+ var REJECTION_HANDLED = 'rejectionhandled';
5949
+ var PENDING = 0;
5950
+ var FULFILLED = 1;
5951
+ var REJECTED = 2;
5952
+ var HANDLED = 1;
5953
+ var UNHANDLED = 2;
6031
5954
 
6032
- // `String.prototype.includes` method
6033
- // https://tc39.es/ecma262/#sec-string.prototype.includes
6034
- $$e({ target: 'String', proto: true, forced: !correctIsRegExpLogic$2('includes') }, {
6035
- includes: function includes(searchString /* , position = 0 */) {
6036
- return !!~stringIndexOf$2(
6037
- toString$h(requireObjectCoercible$9(this)),
6038
- toString$h(notARegExp$2(searchString)),
6039
- arguments.length > 1 ? arguments[1] : undefined
6040
- );
6041
- }
6042
- });
5955
+ var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
6043
5956
 
6044
- function useMediaQuery(query) {
6045
- const [matches, setMatches] = useState(false);
6046
- useEffect(() => {
6047
- const media = window.matchMedia(query);
6048
- if (media.matches !== matches) {
6049
- setMatches(media.matches);
6050
- }
6051
- const listener = () => {
6052
- setMatches(media.matches);
6053
- };
6054
- media.addEventListener('change', listener);
6055
- return () => media.removeEventListener('change', listener);
6056
- }, [matches, query]);
6057
- return matches;
6058
- }
5957
+ // helpers
5958
+ var isThenable = function (it) {
5959
+ var then;
5960
+ return isObject$6(it) && isCallable$5(then = it.then) ? then : false;
5961
+ };
6059
5962
 
6060
- const _excluded$t = ["id", "title", "description", "position", "dismissAfter", "variant", "onClick", "onRemove", "isExternalOfAction", "onClickOfAction", "captionOfAction", "hrefOfAction"];
6061
- var _jsxFileName$V = "/home/alfiantryp/Projects/majoo-ui/packages/react/src/components/toast/Toast.js";
6062
- const TOAST_WIDTH = 576;
6063
- const ANIMATION_DURATION = 400;
6064
- const TOP_RIGHT_POSITION = 'top-right';
6065
- const TOP_LEFT_POSITION = 'top-left';
6066
- const BOTTOM_RIGHT_POSITION = 'bottom-right';
6067
- const BOTTOM_LEFT_POSITION = 'bottom_left';
6068
- const positions = [TOP_RIGHT_POSITION, TOP_LEFT_POSITION, BOTTOM_RIGHT_POSITION, BOTTOM_LEFT_POSITION];
6069
- const toastEnter = position => keyframes({
6070
- '0%': {
6071
- left: position === 'left' ? `-${TOAST_WIDTH}px` : 'unset',
6072
- right: position === 'right' ? `-${TOAST_WIDTH}px` : 'unset',
6073
- opacity: '0'
6074
- },
6075
- '100%': {
6076
- left: position === 'left' ? '0' : 'unset',
6077
- right: position === 'right' ? '0' : 'unset',
6078
- opacity: '1'
6079
- }
6080
- });
6081
- const toastExit = position => keyframes({
6082
- '0%': {
6083
- transform: 'translateX(0%)',
6084
- opacity: '1'
6085
- },
6086
- '100%': {
6087
- transform: `translateX(${position === 'right' ? '100%' : '-100%'})`,
6088
- opacity: '0'
6089
- }
6090
- });
6091
- const toastAnimationStyle = position => ({
6092
- '&[state="entering"], &[state="entered"]': {
6093
- animationFillMode: 'forwards',
6094
- animationName: toastEnter(position),
6095
- animationDuration: `${ANIMATION_DURATION}ms`
6096
- },
6097
- '&[state="exiting"]': {
6098
- animationFillMode: 'forwards',
6099
- animationName: toastExit(position),
6100
- animationDuration: `${ANIMATION_DURATION * 2}ms`
6101
- },
6102
- '&[state="entered"]': {
6103
- right: 0,
6104
- opacity: '1'
6105
- }
6106
- });
6107
- const Root = styled('div', {
6108
- display: 'block',
6109
- maxWidth: `${TOAST_WIDTH}px`,
6110
- // width: `${TOAST_WIDTH}px`,
6111
- height: '100%',
6112
- position: 'relative',
6113
- opacity: 0,
6114
- variants: {
6115
- hPosition: {
6116
- right: toastAnimationStyle('right'),
6117
- left: toastAnimationStyle('left')
6118
- },
6119
- vPosition: {
6120
- top: {
6121
- marginTop: '$spacing-05'
6122
- },
6123
- bottom: {
6124
- marginBottom: '$spacing-05'
6125
- }
6126
- }
6127
- }
6128
- });
6129
- const StyledToast = styled(Flex$1, {
6130
- // width: '100%',
6131
- // maxWidth: TOAST_WIDTH,
6132
- padding: '$spacing-03',
6133
- textAlign: 'left',
6134
- borderRadius: 8,
6135
- pointer: 'default',
6136
- variants: {
6137
- variant: {
6138
- info: {
6139
- backgroundColor: '$blue100',
6140
- border: '1px solid $hlNews'
6141
- },
6142
- warning: {
6143
- backgroundColor: '$bgProcess',
6144
- border: '1px solid $hlProcess'
6145
- },
6146
- success: {
6147
- backgroundColor: '$bgSuccess',
6148
- border: '1px solid $hlSuccess'
6149
- },
6150
- failed: {
6151
- backgroundColor: '$bgFailed',
6152
- border: '1px solid $hlFailed'
6153
- },
6154
- pending: {
6155
- backgroundColor: '$bgProcess',
6156
- border: '1px solid $orange500'
6157
- }
6158
- },
6159
- hasAction: {
6160
- true: {
6161
- cursor: 'pointer'
6162
- }
6163
- }
6164
- }
6165
- });
6166
- const LeftBar = styled('div', {
6167
- width: '4px',
6168
- alignSelf: 'stretch',
6169
- borderRadius: '$lg',
6170
- marginRight: '$spacing-03',
6171
- variants: {
6172
- variant: {
6173
- info: {
6174
- backgroundColor: '$hlNews'
6175
- },
6176
- warning: {
6177
- backgroundColor: '$hlProcess'
6178
- },
6179
- success: {
6180
- backgroundColor: '$hlSuccess'
6181
- },
6182
- failed: {
6183
- backgroundColor: '$hlFailed'
6184
- },
6185
- pending: {
6186
- backgroundColor: '$orange500'
6187
- }
6188
- }
6189
- }
6190
- });
6191
- const DescriptionField = styled(Paragraph, {
6192
- display: '-webkit-box',
6193
- '-webkit-line-clamp': '3',
6194
- '-webkit-box-orient': 'vertical',
6195
- overflow: 'hidden',
6196
- whiteSpace: 'unset'
6197
- });
6198
- const CloseButton$1 = styled(Flex$1, {
6199
- cursor: 'pointer',
6200
- size: '20px',
6201
- borderRadius: '$round',
6202
- '&:hover': {
6203
- backgroundColor: 'rgba(0, 0, 0, .05)'
6204
- },
6205
- alignSelf: 'start',
6206
- variants: {
6207
- hasTitle: {
6208
- false: {
6209
- alignSelf: 'center'
6210
- }
6211
- }
6212
- }
6213
- });
6214
- const Toast = _ref => {
6215
- let {
6216
- id,
6217
- title,
6218
- description,
6219
- position,
6220
- dismissAfter,
6221
- variant,
6222
- onClick,
6223
- onRemove,
6224
- isExternalOfAction,
6225
- onClickOfAction,
6226
- captionOfAction,
6227
- hrefOfAction
6228
- } = _ref,
6229
- rest = _objectWithoutPropertiesLoose(_ref, _excluded$t);
6230
- const [isOpen, setIsOpen] = React.useState(false);
6231
- const isMobile = useMediaQuery(`(max-width: 767px`);
6232
- const close = React.useCallback(() => {
6233
- setIsOpen(false);
6234
- }, [setIsOpen]);
6235
- React.useEffect(() => {
6236
- let currentTimer = null;
6237
- setIsOpen(true);
6238
- currentTimer = setTimeout(() => {
6239
- close();
6240
- }, dismissAfter);
6241
- return () => {
6242
- if (currentTimer) {
6243
- clearTimeout(currentTimer);
5963
+ var callReaction = function (reaction, state) {
5964
+ var value = state.value;
5965
+ var ok = state.state == FULFILLED;
5966
+ var handler = ok ? reaction.ok : reaction.fail;
5967
+ var resolve = reaction.resolve;
5968
+ var reject = reaction.reject;
5969
+ var domain = reaction.domain;
5970
+ var result, then, exited;
5971
+ try {
5972
+ if (handler) {
5973
+ if (!ok) {
5974
+ if (state.rejection === UNHANDLED) onHandleUnhandled(state);
5975
+ state.rejection = HANDLED;
6244
5976
  }
6245
- };
6246
- }, [dismissAfter]);
6247
- return /*#__PURE__*/React.createElement(Transition, {
6248
- appear: true,
6249
- in: isOpen,
6250
- timeout: {
6251
- enter: ANIMATION_DURATION + 100,
6252
- exit: ANIMATION_DURATION + 400
6253
- },
6254
- unmountOnExit: true,
6255
- onExited: onRemove,
6256
- __self: undefined,
6257
- __source: {
6258
- fileName: _jsxFileName$V,
6259
- lineNumber: 216,
6260
- columnNumber: 5
6261
- }
6262
- }, state => /*#__PURE__*/React.createElement(Root, _extends({
6263
- id: id,
6264
- state: state,
6265
- css: {
6266
- maxWidth: isMobile ? '80vw' : TOAST_WIDTH
6267
- },
6268
- hPosition: position.includes('left') ? 'left' : 'right',
6269
- vPosition: position.includes('top') ? 'top' : 'bottom'
6270
- }, rest, {
6271
- __self: undefined,
6272
- __source: {
6273
- fileName: _jsxFileName$V,
6274
- lineNumber: 227,
6275
- columnNumber: 9
6276
- }
6277
- }), /*#__PURE__*/React.createElement(StyledToast, {
6278
- variant: variant,
6279
- hasAction: !!onClick,
6280
- onClick: onClick,
6281
- __self: undefined,
6282
- __source: {
6283
- fileName: _jsxFileName$V,
6284
- lineNumber: 235,
6285
- columnNumber: 11
6286
- }
6287
- }, /*#__PURE__*/React.createElement(Flex$1, {
6288
- direction: "column",
6289
- __self: undefined,
6290
- __source: {
6291
- fileName: _jsxFileName$V,
6292
- lineNumber: 236,
6293
- columnNumber: 13
6294
- }
6295
- }, /*#__PURE__*/React.createElement(Flex$1, {
6296
- direction: "row",
6297
- __self: undefined,
6298
- __source: {
6299
- fileName: _jsxFileName$V,
6300
- lineNumber: 237,
6301
- columnNumber: 15
6302
- }
6303
- }, /*#__PURE__*/React.createElement(LeftBar, {
6304
- variant: variant,
6305
- __self: undefined,
6306
- __source: {
6307
- fileName: _jsxFileName$V,
6308
- lineNumber: 238,
6309
- columnNumber: 17
6310
- }
6311
- }), /*#__PURE__*/React.createElement(Flex$1, {
6312
- gap: 2,
6313
- direction: "column",
6314
- css: {
6315
- flex: 1
6316
- },
6317
- __self: undefined,
6318
- __source: {
6319
- fileName: _jsxFileName$V,
6320
- lineNumber: 239,
6321
- columnNumber: 17
6322
- }
6323
- }, title && /*#__PURE__*/React.createElement(Flex$1, {
6324
- justify: "between",
6325
- __self: undefined,
6326
- __source: {
6327
- fileName: _jsxFileName$V,
6328
- lineNumber: 247,
6329
- columnNumber: 21
5977
+ if (handler === true) result = value;
5978
+ else {
5979
+ if (domain) domain.enter();
5980
+ result = handler(value); // can throw
5981
+ if (domain) {
5982
+ domain.exit();
5983
+ exited = true;
5984
+ }
5985
+ }
5986
+ if (result === reaction.promise) {
5987
+ reject(TypeError$3('Promise-chain cycle'));
5988
+ } else if (then = isThenable(result)) {
5989
+ call$g(then, result, resolve, reject);
5990
+ } else resolve(result);
5991
+ } else reject(value);
5992
+ } catch (error) {
5993
+ if (domain && !exited) domain.exit();
5994
+ reject(error);
5995
+ }
5996
+ };
5997
+
5998
+ var notify = function (state, isReject) {
5999
+ if (state.notified) return;
6000
+ state.notified = true;
6001
+ microtask(function () {
6002
+ var reactions = state.reactions;
6003
+ var reaction;
6004
+ while (reaction = reactions.get()) {
6005
+ callReaction(reaction, state);
6330
6006
  }
6331
- }, /*#__PURE__*/React.createElement(Heading, {
6332
- heading: "sectionTitle",
6333
- css: {
6334
- lineHeight: '$long-content-regular',
6335
- flex: 1,
6336
- whiteSpace: 'unset',
6337
- overflow: 'hidden',
6338
- textOverflow: 'ellipsis'
6339
- },
6340
- __self: undefined,
6341
- __source: {
6342
- fileName: _jsxFileName$V,
6343
- lineNumber: 248,
6344
- columnNumber: 23
6007
+ state.notified = false;
6008
+ if (isReject && !state.rejection) onUnhandled(state);
6009
+ });
6010
+ };
6011
+
6012
+ var dispatchEvent = function (name, promise, reason) {
6013
+ var event, handler;
6014
+ if (DISPATCH_EVENT) {
6015
+ event = document$1.createEvent('Event');
6016
+ event.promise = promise;
6017
+ event.reason = reason;
6018
+ event.initEvent(name, false, true);
6019
+ global$9.dispatchEvent(event);
6020
+ } else event = { promise: promise, reason: reason };
6021
+ if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$9['on' + name])) handler(event);
6022
+ else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
6023
+ };
6024
+
6025
+ var onUnhandled = function (state) {
6026
+ call$g(task, global$9, function () {
6027
+ var promise = state.facade;
6028
+ var value = state.value;
6029
+ var IS_UNHANDLED = isUnhandled(state);
6030
+ var result;
6031
+ if (IS_UNHANDLED) {
6032
+ result = perform$2(function () {
6033
+ if (IS_NODE$1) {
6034
+ process$1.emit('unhandledRejection', value, promise);
6035
+ } else dispatchEvent(UNHANDLED_REJECTION, promise, value);
6036
+ });
6037
+ // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
6038
+ state.rejection = IS_NODE$1 || isUnhandled(state) ? UNHANDLED : HANDLED;
6039
+ if (result.error) throw result.value;
6345
6040
  }
6346
- }, title)), /*#__PURE__*/React.createElement(DescriptionField, {
6347
- paragraph: "longContentRegular",
6348
- color: "secondary",
6349
- __self: undefined,
6350
- __source: {
6351
- fileName: _jsxFileName$V,
6352
- lineNumber: 262,
6353
- columnNumber: 19
6041
+ });
6042
+ };
6043
+
6044
+ var isUnhandled = function (state) {
6045
+ return state.rejection !== HANDLED && !state.parent;
6046
+ };
6047
+
6048
+ var onHandleUnhandled = function (state) {
6049
+ call$g(task, global$9, function () {
6050
+ var promise = state.facade;
6051
+ if (IS_NODE$1) {
6052
+ process$1.emit('rejectionHandled', promise);
6053
+ } else dispatchEvent(REJECTION_HANDLED, promise, state.value);
6054
+ });
6055
+ };
6056
+
6057
+ var bind$4 = function (fn, state, unwrap) {
6058
+ return function (value) {
6059
+ fn(state, value, unwrap);
6060
+ };
6061
+ };
6062
+
6063
+ var internalReject = function (state, value, unwrap) {
6064
+ if (state.done) return;
6065
+ state.done = true;
6066
+ if (unwrap) state = unwrap;
6067
+ state.value = value;
6068
+ state.state = REJECTED;
6069
+ notify(state, true);
6070
+ };
6071
+
6072
+ var internalResolve = function (state, value, unwrap) {
6073
+ if (state.done) return;
6074
+ state.done = true;
6075
+ if (unwrap) state = unwrap;
6076
+ try {
6077
+ if (state.facade === value) throw TypeError$3("Promise can't be resolved itself");
6078
+ var then = isThenable(value);
6079
+ if (then) {
6080
+ microtask(function () {
6081
+ var wrapper = { done: false };
6082
+ try {
6083
+ call$g(then, value,
6084
+ bind$4(internalResolve, wrapper, state),
6085
+ bind$4(internalReject, wrapper, state)
6086
+ );
6087
+ } catch (error) {
6088
+ internalReject(wrapper, error, state);
6089
+ }
6090
+ });
6091
+ } else {
6092
+ state.value = value;
6093
+ state.state = FULFILLED;
6094
+ notify(state, false);
6354
6095
  }
6355
- }, description)), /*#__PURE__*/React.createElement(CloseButton$1, {
6356
- onClick: e => {
6357
- e.preventDefault();
6358
- e.stopPropagation();
6359
- close();
6360
- },
6361
- align: "center",
6362
- justify: "center",
6363
- hasTitle: !!title,
6364
- __self: undefined,
6365
- __source: {
6366
- fileName: _jsxFileName$V,
6367
- lineNumber: 266,
6368
- columnNumber: 17
6096
+ } catch (error) {
6097
+ internalReject({ done: false }, error, state);
6098
+ }
6099
+ };
6100
+
6101
+ // constructor polyfill
6102
+ if (FORCED_PROMISE_CONSTRUCTOR$4) {
6103
+ // 25.4.3.1 Promise(executor)
6104
+ PromiseConstructor = function Promise(executor) {
6105
+ anInstance$2(this, PromisePrototype);
6106
+ aCallable$5(executor);
6107
+ call$g(Internal, this);
6108
+ var state = getInternalPromiseState(this);
6109
+ try {
6110
+ executor(bind$4(internalResolve, state), bind$4(internalReject, state));
6111
+ } catch (error) {
6112
+ internalReject(state, error);
6369
6113
  }
6370
- }, /*#__PURE__*/React.createElement(CloseOutline, {
6371
- color: colors$8.iconSecondary,
6372
- size: "16px",
6373
- __self: undefined,
6374
- __source: {
6375
- fileName: _jsxFileName$V,
6376
- lineNumber: 276,
6377
- columnNumber: 19
6114
+ };
6115
+
6116
+ PromisePrototype = PromiseConstructor.prototype;
6117
+
6118
+ // eslint-disable-next-line no-unused-vars -- required for `.length`
6119
+ Internal = function Promise(executor) {
6120
+ setInternalState$3(this, {
6121
+ type: PROMISE,
6122
+ done: false,
6123
+ notified: false,
6124
+ parent: false,
6125
+ reactions: new Queue(),
6126
+ rejection: false,
6127
+ state: PENDING,
6128
+ value: undefined
6129
+ });
6130
+ };
6131
+
6132
+ // `Promise.prototype.then` method
6133
+ // https://tc39.es/ecma262/#sec-promise.prototype.then
6134
+ Internal.prototype = defineBuiltIn$7(PromisePrototype, 'then', function then(onFulfilled, onRejected) {
6135
+ var state = getInternalPromiseState(this);
6136
+ var reaction = newPromiseCapability$1(speciesConstructor$1(this, PromiseConstructor));
6137
+ state.parent = true;
6138
+ reaction.ok = isCallable$5(onFulfilled) ? onFulfilled : true;
6139
+ reaction.fail = isCallable$5(onRejected) && onRejected;
6140
+ reaction.domain = IS_NODE$1 ? process$1.domain : undefined;
6141
+ if (state.state == PENDING) state.reactions.add(reaction);
6142
+ else microtask(function () {
6143
+ callReaction(reaction, state);
6144
+ });
6145
+ return reaction.promise;
6146
+ });
6147
+
6148
+ OwnPromiseCapability = function () {
6149
+ var promise = new Internal();
6150
+ var state = getInternalPromiseState(promise);
6151
+ this.promise = promise;
6152
+ this.resolve = bind$4(internalResolve, state);
6153
+ this.reject = bind$4(internalReject, state);
6154
+ };
6155
+
6156
+ newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) {
6157
+ return C === PromiseConstructor || C === PromiseWrapper
6158
+ ? new OwnPromiseCapability(C)
6159
+ : newGenericPromiseCapability(C);
6160
+ };
6161
+
6162
+ if (isCallable$5(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) {
6163
+ nativeThen = NativePromisePrototype$1.then;
6164
+
6165
+ if (!NATIVE_PROMISE_SUBCLASSING) {
6166
+ // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
6167
+ defineBuiltIn$7(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) {
6168
+ var that = this;
6169
+ return new PromiseConstructor(function (resolve, reject) {
6170
+ call$g(nativeThen, that, resolve, reject);
6171
+ }).then(onFulfilled, onRejected);
6172
+ // https://github.com/zloirock/core-js/issues/640
6173
+ }, { unsafe: true });
6378
6174
  }
6379
- }))), (hrefOfAction || isExternalOfAction || onClickOfAction) && /*#__PURE__*/React.createElement(Link, {
6380
- href: hrefOfAction,
6381
- isExternal: isExternalOfAction,
6382
- onClick: onClickOfAction,
6383
- color: variant,
6384
- css: {
6385
- alignSelf: 'self-end',
6386
- marginTop: '$spacing-03'
6387
- },
6388
- __self: undefined,
6389
- __source: {
6390
- fileName: _jsxFileName$V,
6391
- lineNumber: 280,
6392
- columnNumber: 17
6175
+
6176
+ // make `.constructor === Promise` work for native promise-based APIs
6177
+ try {
6178
+ delete NativePromisePrototype$1.constructor;
6179
+ } catch (error) { /* empty */ }
6180
+
6181
+ // make `instanceof Promise` work for native promise-based APIs
6182
+ if (setPrototypeOf$1) {
6183
+ setPrototypeOf$1(NativePromisePrototype$1, PromisePrototype);
6393
6184
  }
6394
- }, captionOfAction)))));
6185
+ }
6186
+ }
6187
+
6188
+ $$j({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, {
6189
+ Promise: PromiseConstructor
6190
+ });
6191
+
6192
+ setToStringTag$2(PromiseConstructor, PROMISE, false);
6193
+ setSpecies$1(PROMISE);
6194
+
6195
+ var wellKnownSymbol$7 = wellKnownSymbol$l;
6196
+ var Iterators$1 = iterators;
6197
+
6198
+ var ITERATOR$6 = wellKnownSymbol$7('iterator');
6199
+ var ArrayPrototype = Array.prototype;
6200
+
6201
+ // check on default Array iterator
6202
+ var isArrayIteratorMethod$2 = function (it) {
6203
+ return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$6] === it);
6395
6204
  };
6396
- Toast.displayName = 'Toast';
6397
- Toast.propTypes = {
6398
- id: PropTypes.string,
6399
- title: PropTypes.string,
6400
- description: PropTypes.string,
6401
- position: PropTypes.oneOf(positions).isRequired,
6402
- dismissAfter: PropTypes.number,
6403
- variant: PropTypes.string.isRequired,
6404
- onClick: PropTypes.func,
6405
- onRemove: PropTypes.func,
6406
- disabledOfflineIntercept: PropTypes.bool
6205
+
6206
+ var classof$3 = classof$8;
6207
+ var getMethod$5 = getMethod$7;
6208
+ var isNullOrUndefined$4 = isNullOrUndefined$8;
6209
+ var Iterators = iterators;
6210
+ var wellKnownSymbol$6 = wellKnownSymbol$l;
6211
+
6212
+ var ITERATOR$5 = wellKnownSymbol$6('iterator');
6213
+
6214
+ var getIteratorMethod$4 = function (it) {
6215
+ if (!isNullOrUndefined$4(it)) return getMethod$5(it, ITERATOR$5)
6216
+ || getMethod$5(it, '@@iterator')
6217
+ || Iterators[classof$3(it)];
6407
6218
  };
6408
- Toast.defaultProps = {
6409
- dismissAfter: 5000
6219
+
6220
+ var call$f = functionCall;
6221
+ var aCallable$4 = aCallable$a;
6222
+ var anObject$c = anObject$j;
6223
+ var tryToString$2 = tryToString$5;
6224
+ var getIteratorMethod$3 = getIteratorMethod$4;
6225
+
6226
+ var $TypeError$4 = TypeError;
6227
+
6228
+ var getIterator$3 = function (argument, usingIterator) {
6229
+ var iteratorMethod = arguments.length < 2 ? getIteratorMethod$3(argument) : usingIterator;
6230
+ if (aCallable$4(iteratorMethod)) return anObject$c(call$f(iteratorMethod, argument));
6231
+ throw $TypeError$4(tryToString$2(argument) + ' is not iterable');
6410
6232
  };
6411
6233
 
6412
- const _excluded$s = ["preventDuplicate"];
6413
- var _jsxFileName$U = "/home/alfiantryp/Projects/majoo-ui/packages/react/src/components/toast/ToastContainer.js";
6414
- const ToastBox = styled(Flex$1, {
6415
- position: 'fixed',
6416
- variants: {
6417
- position: {
6418
- [TOP_RIGHT_POSITION]: {
6419
- top: '8%',
6420
- right: '4%',
6421
- flexDirection: 'column-reverse'
6422
- },
6423
- [TOP_LEFT_POSITION]: {
6424
- top: '8%',
6425
- left: '4%',
6426
- flexDirection: 'column-reverse'
6427
- },
6428
- [BOTTOM_RIGHT_POSITION]: {
6429
- bottom: '8%',
6430
- right: '4%',
6431
- flexDirection: 'column'
6432
- },
6433
- [BOTTOM_LEFT_POSITION]: {
6434
- bottom: '8%',
6435
- left: '4%',
6436
- flexDirection: 'column'
6437
- }
6234
+ var call$e = functionCall;
6235
+ var anObject$b = anObject$j;
6236
+ var getMethod$4 = getMethod$7;
6237
+
6238
+ var iteratorClose$2 = function (iterator, kind, value) {
6239
+ var innerResult, innerError;
6240
+ anObject$b(iterator);
6241
+ try {
6242
+ innerResult = getMethod$4(iterator, 'return');
6243
+ if (!innerResult) {
6244
+ if (kind === 'throw') throw value;
6245
+ return value;
6438
6246
  }
6439
- },
6440
- defaultVariants: {
6441
- position: 'top-right'
6247
+ innerResult = call$e(innerResult, iterator);
6248
+ } catch (error) {
6249
+ innerError = true;
6250
+ innerResult = error;
6442
6251
  }
6443
- });
6444
- const ToastContainer = ({
6445
- toasts,
6446
- position
6447
- }) => {
6448
- const {
6449
- removeToast
6450
- } = React.useContext(ToastContext);
6451
- return /*#__PURE__*/React.createElement(Portal, {
6452
- style: {
6453
- top: 0,
6454
- left: 0,
6455
- position: 'absolute',
6456
- zIndex: 2147483647
6457
- },
6458
- __self: undefined,
6459
- __source: {
6460
- fileName: _jsxFileName$U,
6461
- lineNumber: 43,
6462
- columnNumber: 5
6252
+ if (kind === 'throw') throw value;
6253
+ if (innerError) throw innerResult;
6254
+ anObject$b(innerResult);
6255
+ return value;
6256
+ };
6257
+
6258
+ var bind$3 = functionBindContext;
6259
+ var call$d = functionCall;
6260
+ var anObject$a = anObject$j;
6261
+ var tryToString$1 = tryToString$5;
6262
+ var isArrayIteratorMethod$1 = isArrayIteratorMethod$2;
6263
+ var lengthOfArrayLike$4 = lengthOfArrayLike$6;
6264
+ var isPrototypeOf$2 = objectIsPrototypeOf;
6265
+ var getIterator$2 = getIterator$3;
6266
+ var getIteratorMethod$2 = getIteratorMethod$4;
6267
+ var iteratorClose$1 = iteratorClose$2;
6268
+
6269
+ var $TypeError$3 = TypeError;
6270
+
6271
+ var Result = function (stopped, result) {
6272
+ this.stopped = stopped;
6273
+ this.result = result;
6274
+ };
6275
+
6276
+ var ResultPrototype = Result.prototype;
6277
+
6278
+ var iterate$2 = function (iterable, unboundFunction, options) {
6279
+ var that = options && options.that;
6280
+ var AS_ENTRIES = !!(options && options.AS_ENTRIES);
6281
+ var IS_RECORD = !!(options && options.IS_RECORD);
6282
+ var IS_ITERATOR = !!(options && options.IS_ITERATOR);
6283
+ var INTERRUPTED = !!(options && options.INTERRUPTED);
6284
+ var fn = bind$3(unboundFunction, that);
6285
+ var iterator, iterFn, index, length, result, next, step;
6286
+
6287
+ var stop = function (condition) {
6288
+ if (iterator) iteratorClose$1(iterator, 'normal', condition);
6289
+ return new Result(true, condition);
6290
+ };
6291
+
6292
+ var callFn = function (value) {
6293
+ if (AS_ENTRIES) {
6294
+ anObject$a(value);
6295
+ return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
6296
+ } return INTERRUPTED ? fn(value, stop) : fn(value);
6297
+ };
6298
+
6299
+ if (IS_RECORD) {
6300
+ iterator = iterable.iterator;
6301
+ } else if (IS_ITERATOR) {
6302
+ iterator = iterable;
6303
+ } else {
6304
+ iterFn = getIteratorMethod$2(iterable);
6305
+ if (!iterFn) throw $TypeError$3(tryToString$1(iterable) + ' is not iterable');
6306
+ // optimisation for array iterators
6307
+ if (isArrayIteratorMethod$1(iterFn)) {
6308
+ for (index = 0, length = lengthOfArrayLike$4(iterable); length > index; index++) {
6309
+ result = callFn(iterable[index]);
6310
+ if (result && isPrototypeOf$2(ResultPrototype, result)) return result;
6311
+ } return new Result(false);
6463
6312
  }
6464
- }, /*#__PURE__*/React.createElement(ToastBox, {
6465
- position: position,
6466
- __self: undefined,
6467
- __source: {
6468
- fileName: _jsxFileName$U,
6469
- lineNumber: 44,
6470
- columnNumber: 7
6313
+ iterator = getIterator$2(iterable, iterFn);
6314
+ }
6315
+
6316
+ next = IS_RECORD ? iterable.next : iterator.next;
6317
+ while (!(step = call$d(next, iterator)).done) {
6318
+ try {
6319
+ result = callFn(step.value);
6320
+ } catch (error) {
6321
+ iteratorClose$1(iterator, 'throw', error);
6471
6322
  }
6472
- }, toasts.map((item, index) => {
6473
- const {
6474
- preventDuplicate
6475
- } = item,
6476
- toast = _objectWithoutPropertiesLoose(item, _excluded$s);
6477
- return /*#__PURE__*/React.createElement(Toast, _extends({
6478
- key: preventDuplicate ? toast.id : `${toast.id}-${index}`,
6479
- onRemove: () => removeToast(toast.id)
6480
- }, toast, {
6481
- __self: undefined,
6482
- __source: {
6483
- fileName: _jsxFileName$U,
6484
- lineNumber: 47,
6485
- columnNumber: 18
6486
- }
6487
- }));
6488
- })));
6323
+ if (typeof result == 'object' && result && isPrototypeOf$2(ResultPrototype, result)) return result;
6324
+ } return new Result(false);
6489
6325
  };
6490
6326
 
6491
- const getOnLineStatus = () => typeof navigator !== 'undefined' && typeof navigator.onLine === 'boolean' ? navigator.onLine : true;
6492
- const useNavigatorOnLine = () => {
6493
- const [status, setStatus] = React__default.useState(getOnLineStatus());
6494
- const setOnline = () => setStatus(true);
6495
- const setOffline = () => setStatus(false);
6496
- React__default.useEffect(() => {
6497
- window.addEventListener('online', setOnline);
6498
- window.addEventListener('offline', setOffline);
6499
- return () => {
6500
- window.removeEventListener('online', setOnline);
6501
- window.removeEventListener('offline', setOffline);
6327
+ var wellKnownSymbol$5 = wellKnownSymbol$l;
6328
+
6329
+ var ITERATOR$4 = wellKnownSymbol$5('iterator');
6330
+ var SAFE_CLOSING = false;
6331
+
6332
+ try {
6333
+ var called = 0;
6334
+ var iteratorWithReturn = {
6335
+ next: function () {
6336
+ return { done: !!called++ };
6337
+ },
6338
+ 'return': function () {
6339
+ SAFE_CLOSING = true;
6340
+ }
6341
+ };
6342
+ iteratorWithReturn[ITERATOR$4] = function () {
6343
+ return this;
6344
+ };
6345
+ // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
6346
+ Array.from(iteratorWithReturn, function () { throw 2; });
6347
+ } catch (error) { /* empty */ }
6348
+
6349
+ var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) {
6350
+ if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
6351
+ var ITERATION_SUPPORT = false;
6352
+ try {
6353
+ var object = {};
6354
+ object[ITERATOR$4] = function () {
6355
+ return {
6356
+ next: function () {
6357
+ return { done: ITERATION_SUPPORT = true };
6358
+ }
6359
+ };
6502
6360
  };
6503
- }, []);
6504
- return status;
6361
+ exec(object);
6362
+ } catch (error) { /* empty */ }
6363
+ return ITERATION_SUPPORT;
6364
+ };
6365
+
6366
+ var NativePromiseConstructor$1 = promiseNativeConstructor;
6367
+ var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1;
6368
+ var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR;
6369
+
6370
+ var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) {
6371
+ NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ });
6372
+ });
6373
+
6374
+ var $$i = _export;
6375
+ var call$c = functionCall;
6376
+ var aCallable$3 = aCallable$a;
6377
+ var newPromiseCapabilityModule$2 = newPromiseCapability$2;
6378
+ var perform$1 = perform$3;
6379
+ var iterate$1 = iterate$2;
6380
+ var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration;
6381
+
6382
+ // `Promise.all` method
6383
+ // https://tc39.es/ecma262/#sec-promise.all
6384
+ $$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, {
6385
+ all: function all(iterable) {
6386
+ var C = this;
6387
+ var capability = newPromiseCapabilityModule$2.f(C);
6388
+ var resolve = capability.resolve;
6389
+ var reject = capability.reject;
6390
+ var result = perform$1(function () {
6391
+ var $promiseResolve = aCallable$3(C.resolve);
6392
+ var values = [];
6393
+ var counter = 0;
6394
+ var remaining = 1;
6395
+ iterate$1(iterable, function (promise) {
6396
+ var index = counter++;
6397
+ var alreadyCalled = false;
6398
+ remaining++;
6399
+ call$c($promiseResolve, C, promise).then(function (value) {
6400
+ if (alreadyCalled) return;
6401
+ alreadyCalled = true;
6402
+ values[index] = value;
6403
+ --remaining || resolve(values);
6404
+ }, reject);
6405
+ });
6406
+ --remaining || resolve(values);
6407
+ });
6408
+ if (result.error) reject(result.value);
6409
+ return capability.promise;
6410
+ }
6411
+ });
6412
+
6413
+ var $$h = _export;
6414
+ var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR;
6415
+ var NativePromiseConstructor = promiseNativeConstructor;
6416
+ var getBuiltIn$1 = getBuiltIn$7;
6417
+ var isCallable$4 = isCallable$p;
6418
+ var defineBuiltIn$6 = defineBuiltIn$b;
6419
+
6420
+ var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;
6421
+
6422
+ // `Promise.prototype.catch` method
6423
+ // https://tc39.es/ecma262/#sec-promise.prototype.catch
6424
+ $$h({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, {
6425
+ 'catch': function (onRejected) {
6426
+ return this.then(undefined, onRejected);
6427
+ }
6428
+ });
6429
+
6430
+ // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
6431
+ if (isCallable$4(NativePromiseConstructor)) {
6432
+ var method = getBuiltIn$1('Promise').prototype['catch'];
6433
+ if (NativePromisePrototype['catch'] !== method) {
6434
+ defineBuiltIn$6(NativePromisePrototype, 'catch', method, { unsafe: true });
6435
+ }
6436
+ }
6437
+
6438
+ var $$g = _export;
6439
+ var call$b = functionCall;
6440
+ var aCallable$2 = aCallable$a;
6441
+ var newPromiseCapabilityModule$1 = newPromiseCapability$2;
6442
+ var perform = perform$3;
6443
+ var iterate = iterate$2;
6444
+ var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration;
6445
+
6446
+ // `Promise.race` method
6447
+ // https://tc39.es/ecma262/#sec-promise.race
6448
+ $$g({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {
6449
+ race: function race(iterable) {
6450
+ var C = this;
6451
+ var capability = newPromiseCapabilityModule$1.f(C);
6452
+ var reject = capability.reject;
6453
+ var result = perform(function () {
6454
+ var $promiseResolve = aCallable$2(C.resolve);
6455
+ iterate(iterable, function (promise) {
6456
+ call$b($promiseResolve, C, promise).then(capability.resolve, reject);
6457
+ });
6458
+ });
6459
+ if (result.error) reject(result.value);
6460
+ return capability.promise;
6461
+ }
6462
+ });
6463
+
6464
+ var $$f = _export;
6465
+ var call$a = functionCall;
6466
+ var newPromiseCapabilityModule = newPromiseCapability$2;
6467
+ var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR;
6468
+
6469
+ // `Promise.reject` method
6470
+ // https://tc39.es/ecma262/#sec-promise.reject
6471
+ $$f({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, {
6472
+ reject: function reject(r) {
6473
+ var capability = newPromiseCapabilityModule.f(this);
6474
+ call$a(capability.reject, undefined, r);
6475
+ return capability.promise;
6476
+ }
6477
+ });
6478
+
6479
+ var anObject$9 = anObject$j;
6480
+ var isObject$5 = isObject$e;
6481
+ var newPromiseCapability = newPromiseCapability$2;
6482
+
6483
+ var promiseResolve$1 = function (C, x) {
6484
+ anObject$9(C);
6485
+ if (isObject$5(x) && x.constructor === C) return x;
6486
+ var promiseCapability = newPromiseCapability.f(C);
6487
+ var resolve = promiseCapability.resolve;
6488
+ resolve(x);
6489
+ return promiseCapability.promise;
6505
6490
  };
6506
6491
 
6492
+ var $$e = _export;
6493
+ var getBuiltIn = getBuiltIn$7;
6494
+ var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR;
6495
+ var promiseResolve = promiseResolve$1;
6496
+
6497
+ getBuiltIn('Promise');
6498
+
6499
+ // `Promise.resolve` method
6500
+ // https://tc39.es/ecma262/#sec-promise.resolve
6501
+ $$e({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {
6502
+ resolve: function resolve(x) {
6503
+ return promiseResolve(this, x);
6504
+ }
6505
+ });
6506
+
6507
6507
  var aCallable$1 = aCallable$a;
6508
6508
  var toObject$3 = toObject$7;
6509
6509
  var IndexedObject = indexedObject;
@@ -6641,25 +6641,15 @@ const _excluded$r = ["id", "disabledOfflineIntercept"];
6641
6641
  var _jsxFileName$T = "/home/alfiantryp/Projects/majoo-ui/packages/react/src/components/toast/context/ToastProvider.js";
6642
6642
  let toastCount = 0;
6643
6643
  const ToastProvider = ({
6644
- children
6644
+ children,
6645
+ translations
6645
6646
  }) => {
6646
6647
  const isOnline = useNavigatorOnLine();
6647
6648
  const [toasts, setToasts] = useState([]);
6648
- const [translations, setTranslations] = useState();
6649
6649
  const {
6650
6650
  t,
6651
6651
  i18n
6652
6652
  } = useTranslation(['MajooUI/toast', 'translation']);
6653
- const fetchMultilang = async () => {
6654
- try {
6655
- const response = await fetch('https://pub-366ba540f0c84c41a0d9ac78d8296d22.r2.dev/backend.json');
6656
- const responseJson = await response.json();
6657
- setTranslations(responseJson);
6658
- } catch (error) {
6659
- setTranslations({});
6660
- console.error(error);
6661
- }
6662
- };
6663
6653
  const catchError$1 = useCallback(e => {
6664
6654
  const errorMsg = catchError(e);
6665
6655
  if (translations && translations[errorMsg]) return translations[errorMsg][i18n.language];
@@ -6703,9 +6693,6 @@ const ToastProvider = ({
6703
6693
  const removeToast = React.useCallback(id => {
6704
6694
  setToasts(toastItems => toastItems.filter(t => t.id !== id));
6705
6695
  }, [setToasts]);
6706
- useEffect(() => {
6707
- fetchMultilang();
6708
- }, []);
6709
6696
  return /*#__PURE__*/React.createElement(ToastContext.Provider, {
6710
6697
  value: {
6711
6698
  addToast,
@@ -6714,7 +6701,7 @@ const ToastProvider = ({
6714
6701
  __self: undefined,
6715
6702
  __source: {
6716
6703
  fileName: _jsxFileName$T,
6717
- lineNumber: 90,
6704
+ lineNumber: 74,
6718
6705
  columnNumber: 5
6719
6706
  }
6720
6707
  }, children, /*#__PURE__*/React.createElement(ToastContainer, {
@@ -6723,7 +6710,7 @@ const ToastProvider = ({
6723
6710
  __self: undefined,
6724
6711
  __source: {
6725
6712
  fileName: _jsxFileName$T,
6726
- lineNumber: 92,
6713
+ lineNumber: 76,
6727
6714
  columnNumber: 7
6728
6715
  }
6729
6716
  }), /*#__PURE__*/React.createElement(ToastContainer, {
@@ -6732,7 +6719,7 @@ const ToastProvider = ({
6732
6719
  __self: undefined,
6733
6720
  __source: {
6734
6721
  fileName: _jsxFileName$T,
6735
- lineNumber: 96,
6722
+ lineNumber: 80,
6736
6723
  columnNumber: 7
6737
6724
  }
6738
6725
  }), /*#__PURE__*/React.createElement(ToastContainer, {
@@ -6741,7 +6728,7 @@ const ToastProvider = ({
6741
6728
  __self: undefined,
6742
6729
  __source: {
6743
6730
  fileName: _jsxFileName$T,
6744
- lineNumber: 100,
6731
+ lineNumber: 84,
6745
6732
  columnNumber: 7
6746
6733
  }
6747
6734
  }), /*#__PURE__*/React.createElement(ToastContainer, {
@@ -6750,7 +6737,7 @@ const ToastProvider = ({
6750
6737
  __self: undefined,
6751
6738
  __source: {
6752
6739
  fileName: _jsxFileName$T,
6753
- lineNumber: 104,
6740
+ lineNumber: 88,
6754
6741
  columnNumber: 7
6755
6742
  }
6756
6743
  }));