@muze-nl/metro-oidc 0.8.0 → 0.9.1

package/dist/browser.js

@@ -278,10 +278,23 @@
   function callTracers(tracers, method, ...args) {
     for (const tracer of tracers) {
       if (tracer && typeof tracer[method] == "function") {
-        tracer[method].call(tracer, ...args);
+        callTracer(tracer, method, args);
       }
     }
   }
+  function callTracer(tracer, method, args) {
+    const reportFailure = (error2) => {
+      metroConsole.error("metro: tracer." + method + "() failed", error2);
+    };
+    try {
+      const result = tracer[method].call(tracer, ...args);
+      if (typeof result?.then == "function") {
+        result.then(void 0, reportFailure);
+      }
+    } catch (error2) {
+      reportFailure(error2);
+    }
+  }
   function isPlainObject(value) {
     return value && typeof value == "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
   }
@@ -679,21 +692,250 @@
     return object;
   }
 
-  // ../../node_modules/@muze-nl/assert/src/assert.mjs
-  globalThis.assertEnabled = false;
+  // ../../node_modules/@muze-nl/assert/src/assert-core.mjs
+  var assert_core_exports = {};
+  __export(assert_core_exports, {
+    Optional: () => Optional,
+    Recommended: () => Recommended,
+    Required: () => Required,
+    allOf: () => allOf,
+    anyOf: () => anyOf,
+    assert: () => assert,
+    disable: () => disable,
+    enable: () => enable,
+    error: () => error,
+    fails: () => fails,
+    formatIssue: () => formatIssue,
+    formatIssues: () => formatIssues,
+    instanceOf: () => instanceOf,
+    issues: () => issues,
+    not: () => not,
+    oneOf: () => oneOf,
+    validEmail: () => validEmail,
+    validURL: () => validURL,
+    warn: () => warn
+  });
+  var assertEnabled = false;
   function enable() {
-    globalThis.assertEnabled = true;
+    assertEnabled = true;
   }
   function disable() {
-    globalThis.assertEnabled = false;
+    assertEnabled = false;
+  }
+  function appendPath(path = "", key) {
+    if (typeof path == "undefined" || path == null) {
+      path = "";
+    }
+    if (typeof key == "number") {
+      return `${path}[${key}]`;
+    }
+    return `${path}.${key}`;
+  }
+  function pathToArray(path = "") {
+    if (Array.isArray(path)) {
+      return path;
+    }
+    if (!path) {
+      return [];
+    }
+    let result = [];
+    let matcher = /(?:^|\.)([^.\[\]]+)|\[(\d+)\]/g;
+    let match;
+    while (match = matcher.exec(path)) {
+      if (typeof match[1] != "undefined") {
+        result.push(match[1]);
+      } else if (typeof match[2] != "undefined") {
+        result.push(Number(match[2]));
+      }
+    }
+    return result;
+  }
+  function pathToString(path = []) {
+    if (typeof path == "string") {
+      return path.startsWith(".") ? path.slice(1) : path;
+    }
+    return path.map((part, index) => {
+      if (typeof part == "number") {
+        return `[${part}]`;
+      }
+      return `${index ? "." : ""}${part}`;
+    }).join("");
+  }
+  function describeFunction(value) {
+    if (value === String) {
+      return "string";
+    }
+    if (value === Number) {
+      return "number";
+    }
+    if (value === Boolean) {
+      return "boolean";
+    }
+    return value.name || "function";
+  }
+  function clip(text, maxLength = 60) {
+    if (text.length <= maxLength) {
+      return text;
+    }
+    return text.slice(0, maxLength - 1) + "\u2026";
+  }
+  function quoteString(value) {
+    return `'${clip(String(value).replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n"))}'`;
+  }
+  function jsonSummary(value) {
+    try {
+      let json = JSON.stringify(value);
+      if (typeof json == "string") {
+        return clip(json);
+      }
+    } catch (e) {
+    }
+    let name = value?.constructor?.name;
+    if (name && name != "Object") {
+      return name;
+    }
+    return Object.prototype.toString.call(value);
+  }
+  function formatValue(value) {
+    if (typeof value == "string") {
+      return quoteString(value);
+    }
+    if (typeof value == "undefined") {
+      return "undefined";
+    }
+    if (value === null) {
+      return "null";
+    }
+    if (typeof value == "function") {
+      return describeFunction(value);
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (typeof value == "number" || typeof value == "boolean" || typeof value == "bigint") {
+      return String(value);
+    }
+    if (typeof value == "symbol") {
+      return value.toString();
+    }
+    return jsonSummary(value);
+  }
+  function describeExpected(value) {
+    if (value === String || value === Number || value === Boolean) {
+      return describeFunction(value);
+    }
+    if (typeof value == "function") {
+      return describeFunction(value);
+    }
+    if (value instanceof RegExp) {
+      return value.toString();
+    }
+    if (Array.isArray(value)) {
+      return "[" + value.map(describeExpected).join(", ") + "]";
+    }
+    return formatValue(value);
+  }
+  function describeOneOf(patterns) {
+    return patterns.map(describeExpected).join(", ");
+  }
+  function conciseMessage(message2, actual, expected) {
+    if (message2 == "data and pattern are not equal") {
+      return `expected ${formatValue(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message2 == "data does not match pattern" || /^data\[\d+\] does not match pattern$/.test(message2)) {
+      return `expected ${describeExpected(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message2 == "data is undefined, should match pattern") {
+      return `missing; expected ${describeExpected(expected)}`;
+    }
+    if (message2 == "data is required") {
+      return "required";
+    }
+    if (message2 == "data is an empty string, which is not allowed") {
+      return "empty string is not allowed";
+    }
+    if (message2 == "data is not an object, pattern is") {
+      return "data is not an object";
+    }
+    if (message2 == "data is not an instanceof pattern") {
+      return `expected instance of ${describeExpected(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message2 == "data does not match oneOf patterns" || message2 == "data does not match anyOf patterns") {
+      return `expected one of ${describeOneOf(expected)}, found ${formatValue(actual)}`;
+    }
+    if (message2 == "data matches pattern, when required not to") {
+      return `must not match ${describeExpected(expected)}`;
+    }
+    return message2;
+  }
+  function formatIssue(issue, options = {}) {
+    if (!issue || typeof issue != "object") {
+      return String(issue);
+    }
+    let path = issue.pathString || pathToString(issue.path || []) || "value";
+    let indent = options.indent ?? "";
+    return `${indent}${path}: ${issue.message}`;
+  }
+  function formatIssues(issues2, options = {}) {
+    if (!issues2) {
+      return false;
+    }
+    let indent = options.indent ?? "  - ";
+    return (Array.isArray(issues2) ? issues2 : [issues2]).map((issue) => formatIssue(issue, { ...options, indent }));
+  }
+  function issueFromProblem(problem) {
+    if (!problem || typeof problem != "object") {
+      return {
+        path: [],
+        pathString: "",
+        message: String(problem),
+        expected: void 0,
+        actual: void 0
+      };
+    }
+    let path = pathToArray(problem.path);
+    let pathString = pathToString(path);
+    let actual = problem.actual ?? problem.found;
+    let expected = describeExpected(problem.expected);
+    let message2 = conciseMessage(problem.message, actual, problem.expected);
+    return {
+      path,
+      pathString,
+      message: message2,
+      expected,
+      actual
+    };
+  }
+  function problemsToIssues(problems) {
+    if (!problems) {
+      return [];
+    }
+    let result = [];
+    for (let problem of Array.isArray(problems) ? problems : [problems]) {
+      if (!problem) {
+        continue;
+      }
+      if (problem && typeof problem == "object" && problem.problems) {
+        let nested = problemsToIssues(problem.problems);
+        if (nested.length) {
+          result = result.concat(nested);
+          continue;
+        }
+      }
+      result.push(issueFromProblem(problem));
+    }
+    return result;
   }
   function assert(source, test) {
-    if (globalThis.assertEnabled) {
+    if (assertEnabled) {
       let problems = fails(source, test);
       if (problems) {
-        console.error("\u{1F170}\uFE0F  Assertions failed because of:", problems, "in this source:", source);
-        throw new Error("Assertions failed", {
-          cause: { problems, source }
+        let assertionIssues = problemsToIssues(problems);
+        let formattedIssues = formatIssues(assertionIssues);
+        let message2 = "Assertions failed:\n" + formattedIssues.join("\n");
+        console.error("\u{1F170}\uFE0F  " + message2);
+        throw new Error(message2, {
+          cause: { problems, issues: assertionIssues, source }
         });
       }
     }
@@ -741,9 +983,10 @@
       if (!Array.isArray(data)) {
         return error("data is not an array", data, "anyOf", path);
       }
-      for (let value of data) {
-        if (oneOf(...patterns)(value)) {
-          return error("data does not match anyOf patterns", value, patterns, path);
+      for (let [index, value] of data.entries()) {
+        let itemPath = appendPath(path, index);
+        if (oneOf(...patterns)(value, root, itemPath)) {
+          return error("data does not match anyOf patterns", value, patterns, itemPath);
         }
       }
       return false;
@@ -795,8 +1038,15 @@
       }
     };
   }
+  function issues(data, pattern, root) {
+    let problems = fails(data, pattern, root);
+    if (!problems) {
+      return false;
+    }
+    return problemsToIssues(problems);
+  }
   function fails(data, pattern, root, path = "") {
-    if (!root) {
+    if (typeof root == "undefined") {
       root = data;
     }
     let problems = [];
@@ -817,9 +1067,9 @@
       }
     } else if (pattern instanceof RegExp) {
       if (Array.isArray(data)) {
-        let index = data.findIndex((element, index2) => fails(element, pattern, root, path + "[" + index2 + "]"));
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, appendPath(path, index2)));
         if (index > -1) {
-          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
+          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, appendPath(path, index)));
         }
       } else if (typeof data == "undefined") {
         problems.push(error("data is undefined, should match pattern", data, pattern, path));
@@ -838,22 +1088,23 @@
     } else if (Array.isArray(pattern)) {
       if (!Array.isArray(data)) {
         problems.push(error("data is not an array", data, [], path));
-      }
-      for (let p of pattern) {
-        for (let index of data.keys()) {
-          let problem = fails(data[index], p, root, path + "[" + index + "]");
-          if (Array.isArray(problem)) {
-            problems = problems.concat(problem);
-          } else if (problem) {
-            problems.push(problem);
+      } else {
+        for (let p of pattern) {
+          for (let index of data.keys()) {
+            let problem = fails(data[index], p, root, appendPath(path, index));
+            if (Array.isArray(problem)) {
+              problems = problems.concat(problem);
+            } else if (problem) {
+              problems.push(problem);
+            }
           }
         }
       }
     } else if (pattern && typeof pattern == "object") {
       if (Array.isArray(data)) {
-        let index = data.findIndex((element, index2) => fails(element, pattern, root, path + "[" + index2 + "]"));
+        let index = data.findIndex((element, index2) => fails(element, pattern, root, appendPath(path, index2)));
         if (index > -1) {
-          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, path + "[" + index + "]"));
+          problems.push(error("data[" + index + "] does not match pattern", data[index], pattern, appendPath(path, index)));
         }
       } else if (!data || typeof data != "object") {
         problems.push(error("data is not an object, pattern is", data, pattern, path));
@@ -868,7 +1119,7 @@
           }
         } else {
           for (const [patternKey, subpattern] of Object.entries(pattern)) {
-            let result = fails(data[patternKey], subpattern, root, path + "." + patternKey);
+            let result = fails(data[patternKey], subpattern, root, appendPath(path, patternKey));
             if (result) {
               problems = problems.concat(result);
             }
@@ -885,9 +1136,12 @@
     }
     return false;
   }
-  function error(message2, found, expected, path, problems) {
+  function error(message2, found, expected, path = "", problems) {
+    let pathParts = pathToArray(path);
     let result = {
       path,
+      pathString: pathToString(pathParts),
+      pathParts,
       message: message2,
       found,
       expected
@@ -900,24 +1154,9 @@
   function warn(message2, data, pattern, path) {
     console.warn("\u{1F170}\uFE0F  Assert: " + path, message2, pattern, data);
   }
-  globalThis.assert = {
-    warn,
-    error,
-    assert,
-    enable,
-    disable,
-    Required,
-    Recommended,
-    Optional,
-    oneOf,
-    anyOf,
-    allOf,
-    validURL,
-    validEmail,
-    instanceOf,
-    not,
-    fails
-  };
+
+  // ../../node_modules/@muze-nl/assert/src/assert.mjs
+  globalThis.assert = { ...assert_core_exports };
 
   // ../metro-oauth2/src/tokenstore.mjs
   function tokenStore(site) {
@@ -1019,7 +1258,7 @@
       }
       return oauth2authorized(req, next);
     };
-    async function oauth2authorized(req, next) {
+    async function oauth2authorized(req, next, retryState = {}) {
       getTokensFromLocation();
       const accessToken = options.tokens.get("access_token");
       const refreshToken = options.tokens.get("refresh_token");
@@ -1037,12 +1276,21 @@
         }
         return oauth2authorized(req, next);
       } else {
-        req = request(req, {
+        const authorizedReq = request(req, {
           headers: {
             Authorization: accessToken.type + " " + accessToken.value
           }
         });
-        return next(req);
+        const res = await next(authorizedReq);
+        if (!shouldAuthorizeResponse(res) || retryState.handledRejectedToken) {
+          return res;
+        }
+        options.tokens.delete("access_token");
+        const token = refreshToken ? await refreshAccessToken() : await fetchAccessToken();
+        if (!token) {
+          return response("false");
+        }
+        return oauth2authorized(req, next, { handledRejectedToken: true });
       }
     }
     function getTokensFromLocation() {
@@ -1741,17 +1989,31 @@
       if (res && isJSON(res.headers?.get("Content-Type"))) {
         let tempRes = res.clone();
         let body = await tempRes.text();
+        if (body === "") {
+          return res;
+        }
         try {
           let json2 = JSON.parse(body, options.reviver);
           return res.with({
             body: json2
           });
-        } catch (e) {
+        } catch (error2) {
+          if (!res.ok) {
+            return res;
+          }
+          throw parseError(req, res, error2);
         }
       }
       return res;
     };
   }
+  function parseError(req, res, cause) {
+    const message2 = "jsonmw: could not parse " + res.headers.get("Content-Type") + " response from " + req.url;
+    const error2 = new Error(message2, { cause });
+    error2.request = req;
+    error2.response = res;
+    return error2;
+  }
   var jsonRE = /^application\/([a-zA-Z0-9\-_]+\+)?json\b/;
   function isJSON(contentType) {
     return jsonRE.exec(contentType);
@@ -3261,6 +3523,7 @@
       }
     };
     options = Object.assign({}, defaultOptions, options);
+    const requestedClientInfo = options.client_info;
     assert(options, {
       client: Required(instanceOf(client().constructor)),
       // required because it is set in defaultOptions
@@ -3276,7 +3539,10 @@
       options.openid_configuration = options.store.get("openid_configuration");
     }
     if (!options.client_info?.client_id && options.store.has("client_info")) {
-      options.client_info = options.store.get("client_info");
+      const storedClientInfo = options.store.get("client_info");
+      if (clientInfoMatchesRequest(storedClientInfo, requestedClientInfo)) {
+        options.client_info = storedClientInfo;
+      }
     }
     return async (req, next) => {
       let res;
@@ -3389,6 +3655,16 @@
       return res;
     };
   }
+  function clientInfoMatchesRequest(storedClientInfo, requestedClientInfo) {
+    if (!storedClientInfo?.client_id) {
+      return false;
+    }
+    if (!Array.isArray(requestedClientInfo?.redirect_uris)) {
+      return true;
+    }
+    const storedRedirectUris = new Set(storedClientInfo.redirect_uris || []);
+    return requestedClientInfo.redirect_uris.every((uri) => storedRedirectUris.has(uri));
+  }
   function isRedirected2() {
     return isRedirected();
   }