@equinor/roma-framework 1.1.0 → 2.0.0

package/{router-CrMzSazo.mjs → router-CD1QGwNJ.mjs}

@@ -68,8 +68,8 @@ function __generator(thisArg, body) {
   var _ = { label: 0, sent: function() {
     if (t[0] & 1) throw t[1];
     return t[1];
-  }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-  return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+  }, trys: [], ops: [] }, f, y, t, g;
+  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
     return this;
   }), g;
   function verb(n) {
@@ -161,14 +161,14 @@ function __read(o, n) {
   }
   return ar;
 }
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-    if (ar || !(i in from)) {
-      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-      ar[i] = from[i];
+function __spreadArray(to, from2, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from2.length, ar; i < l; i++) {
+    if (ar || !(i in from2)) {
+      if (!ar) ar = Array.prototype.slice.call(from2, 0, i);
+      ar[i] = from2[i];
     }
   }
-  return to.concat(ar || Array.prototype.slice.call(from));
+  return to.concat(ar || Array.prototype.slice.call(from2));
 }
 function __await(v) {
   return this instanceof __await ? (this.v = v, this) : new __await(v);
@@ -176,7 +176,7 @@ function __await(v) {
 function __asyncGenerator(thisArg, _arguments, generator) {
   if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
   var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
+  return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
     return this;
   }, i;
   function awaitReturn(f) {
@@ -413,7 +413,8 @@ var timeoutProvider = {
     return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
   },
   clearTimeout: function(handle) {
-    return clearTimeout(handle);
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
   },
   delegate: void 0
 };
@@ -947,6 +948,15 @@ var BehaviorSubject = function(_super) {
   };
   return BehaviorSubject2;
 }(Subject);
+function isScheduler(value) {
+  return value && isFunction(value.schedule);
+}
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : void 0;
+}
 var isArrayLike = function(x) {
   return x && typeof x.length === "number" && typeof x !== "function";
 };
@@ -1150,6 +1160,160 @@ function process$1(asyncIterable, subscriber) {
     });
   });
 }
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  if (repeat === void 0) {
+    repeat = false;
+  }
+  var scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat) {
+      parentSubscription.add(this.schedule(null, delay));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat) {
+    return scheduleSubscription;
+  }
+}
+function observeOn(scheduler, delay) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  return operate(function(source, subscriber) {
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.next(value);
+      }, delay);
+    }, function() {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.complete();
+      }, delay);
+    }, function(err) {
+      return executeSchedule(subscriber, scheduler, function() {
+        return subscriber.error(err);
+      }, delay);
+    }));
+  });
+}
+function subscribeOn(scheduler, delay) {
+  if (delay === void 0) {
+    delay = 0;
+  }
+  return operate(function(source, subscriber) {
+    subscriber.add(scheduler.schedule(function() {
+      return source.subscribe(subscriber);
+    }, delay));
+  });
+}
+function scheduleObservable(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function schedulePromise(input, scheduler) {
+  return innerFrom(input).pipe(subscribeOn(scheduler), observeOn(scheduler));
+}
+function scheduleArray(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var i = 0;
+    return scheduler.schedule(function() {
+      if (i === input.length) {
+        subscriber.complete();
+      } else {
+        subscriber.next(input[i++]);
+        if (!subscriber.closed) {
+          this.schedule();
+        }
+      }
+    });
+  });
+}
+function scheduleIterable(input, scheduler) {
+  return new Observable(function(subscriber) {
+    var iterator$1;
+    executeSchedule(subscriber, scheduler, function() {
+      iterator$1 = input[iterator]();
+      executeSchedule(subscriber, scheduler, function() {
+        var _a2;
+        var value;
+        var done;
+        try {
+          _a2 = iterator$1.next(), value = _a2.value, done = _a2.done;
+        } catch (err) {
+          subscriber.error(err);
+          return;
+        }
+        if (done) {
+          subscriber.complete();
+        } else {
+          subscriber.next(value);
+        }
+      }, 0, true);
+    });
+    return function() {
+      return isFunction(iterator$1 === null || iterator$1 === void 0 ? void 0 : iterator$1.return) && iterator$1.return();
+    };
+  });
+}
+function scheduleAsyncIterable(input, scheduler) {
+  if (!input) {
+    throw new Error("Iterable cannot be null");
+  }
+  return new Observable(function(subscriber) {
+    executeSchedule(subscriber, scheduler, function() {
+      var iterator2 = input[Symbol.asyncIterator]();
+      executeSchedule(subscriber, scheduler, function() {
+        iterator2.next().then(function(result) {
+          if (result.done) {
+            subscriber.complete();
+          } else {
+            subscriber.next(result.value);
+          }
+        });
+      }, 0, true);
+    });
+  });
+}
+function scheduleReadableStreamLike(input, scheduler) {
+  return scheduleAsyncIterable(readableStreamLikeToAsyncGenerator(input), scheduler);
+}
+function scheduled(input, scheduler) {
+  if (input != null) {
+    if (isInteropObservable(input)) {
+      return scheduleObservable(input, scheduler);
+    }
+    if (isArrayLike(input)) {
+      return scheduleArray(input, scheduler);
+    }
+    if (isPromise(input)) {
+      return schedulePromise(input, scheduler);
+    }
+    if (isAsyncIterable(input)) {
+      return scheduleAsyncIterable(input, scheduler);
+    }
+    if (isIterable(input)) {
+      return scheduleIterable(input, scheduler);
+    }
+    if (isReadableStreamLike(input)) {
+      return scheduleReadableStreamLike(input, scheduler);
+    }
+  }
+  throw createInvalidObservableTypeError(input);
+}
+function from(input, scheduler) {
+  return scheduler ? scheduled(input, scheduler) : innerFrom(input);
+}
+function of() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var scheduler = popScheduler(args);
+  return from(args, scheduler);
+}
 var EmptyError = createErrorClass(function(_super) {
   return function EmptyErrorImpl() {
     _super(this);
@@ -1157,12 +1321,21 @@ var EmptyError = createErrorClass(function(_super) {
     this.message = "no elements in sequence";
   };
 });
-function map(project, thisArg) {
-  return operate(function(source, subscriber) {
-    var index = 0;
-    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-      subscriber.next(project.call(thisArg, value, index++));
-    }));
+function firstValueFrom(source, config2) {
+  return new Promise(function(resolve, reject) {
+    var subscriber = new SafeSubscriber({
+      next: function(value) {
+        resolve(value);
+        subscriber.unsubscribe();
+      },
+      error: reject,
+      complete: function() {
+        {
+          reject(new EmptyError());
+        }
+      }
+    });
+    source.subscribe(subscriber);
   });
 }
 var reactIs$1 = { exports: {} };
@@ -5090,15 +5263,15 @@ function formatDateTimeRange(config2, getDateTimeFormat) {
   for (var _i = 2; _i < arguments.length; _i++) {
     _a2[_i - 2] = arguments[_i];
   }
-  var from = _a2[0], to = _a2[1], _b = _a2[2], options = _b === void 0 ? {} : _b;
+  var from2 = _a2[0], to = _a2[1], _b = _a2[2], options = _b === void 0 ? {} : _b;
   var timeZone = config2.timeZone, locale = config2.locale, onError = config2.onError;
   var filteredOptions = filterProps(options, DATE_TIME_FORMAT_OPTIONS, timeZone ? { timeZone } : {});
   try {
-    return getDateTimeFormat(locale, filteredOptions).formatRange(from, to);
+    return getDateTimeFormat(locale, filteredOptions).formatRange(from2, to);
   } catch (e) {
     onError(new IntlFormatError("Error formatting date time range.", config2.locale, e));
   }
-  return String(from);
+  return String(from2);
 }
 function formatDateToParts(config2, getDateTimeFormat) {
   var _a2 = [];
@@ -5674,9 +5847,9 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
   }
   let isEmptyPath = toArg === "" || to.pathname === "";
   let toPathname = isEmptyPath ? "/" : to.pathname;
-  let from;
+  let from2;
   if (isPathRelative || toPathname == null) {
-    from = locationPathname;
+    from2 = locationPathname;
   } else {
     let routePathnameIndex = routePathnames.length - 1;
     if (toPathname.startsWith("..")) {
@@ -5687,9 +5860,9 @@ function resolveTo(toArg, routePathnames, locationPathname, isPathRelative) {
       }
       to.pathname = toSegments.join("/");
     }
-    from = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
+    from2 = routePathnameIndex >= 0 ? routePathnames[routePathnameIndex] : "/";
   }
-  let path = resolvePath(to, from);
+  let path = resolvePath(to, from2);
   let hasExplicitTrailingSlash = toPathname && toPathname !== "/" && toPathname.endsWith("/");
   let hasCurrentTrailingSlash = (isEmptyPath || toPathname === ".") && locationPathname.endsWith("/");
   if (!path.pathname.endsWith("/") && (hasExplicitTrailingSlash || hasCurrentTrailingSlash)) {
@@ -5710,32 +5883,25 @@ export {
   EmptyError as E,
   IntlProvider as I,
   Observable as O,
-  Subject as S,
+  Subscription as S,
   __extends as _,
-  innerFrom as a,
-  invariant as b,
+  identity as a,
+  isFunction as b,
   createOperatorSubscriber as c,
-  createPath as d,
-  Subscription as e,
-  __spreadArray as f,
+  invariant as d,
+  createPath as e,
+  firstValueFrom as f,
   getPathContributingMatches as g,
-  __read as h,
-  isFunction as i,
+  of as h,
+  innerFrom as i,
   joinPaths as j,
-  arrRemove as k,
-  iterator as l,
-  map as m,
-  readableStreamLikeToAsyncGenerator as n,
+  from as k,
+  __spreadArray as l,
+  __read as m,
+  arrRemove as n,
   operate as o,
-  isInteropObservable as p,
-  isArrayLike as q,
+  isScheduler as p,
   resolveTo as r,
   stripBasename as s,
-  isPromise as t,
-  isAsyncIterable as u,
-  isIterable as v,
-  warning as w,
-  isReadableStreamLike as x,
-  createInvalidObservableTypeError as y,
-  SafeSubscriber as z
+  warning as w
 };