@kaspernj/api-maker 1.0.2171 → 1.0.2173

package/build/session-expired-error.js

@@ -0,0 +1,19 @@
+// @ts-check
+/**
+ * Raised by the commands pool when a request could not run because the session
+ * had expired (the frontend's believed user diverged from the backend's actual
+ * user) and could not be renewed. Callers can treat this as a benign "please
+ * sign in again" signal — the sign-in form is shown centrally via the Devise
+ * sign-out event — rather than a real command failure.
+ */
+export default class ApiMakerSessionExpiredError extends Error {
+    static apiMakerType = "SessionExpiredError";
+    apiMakerType = "SessionExpiredError";
+    /** @param {string} [message] */
+    constructor(message = "The session has expired") {
+        super(message);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, ApiMakerSessionExpiredError);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1leHBpcmVkLWVycm9yLmpzIiwic291cmNlUm9vdCI6Ii9zcmMvIiwic291cmNlcyI6WyJzZXNzaW9uLWV4cGlyZWQtZXJyb3IuanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsWUFBWTtBQUVaOzs7Ozs7R0FNRztBQUNILE1BQU0sQ0FBQyxPQUFPLE9BQU8sMkJBQTRCLFNBQVEsS0FBSztJQUM1RCxNQUFNLENBQUMsWUFBWSxHQUFHLHFCQUFxQixDQUFBO0lBQzNDLFlBQVksR0FBRyxxQkFBcUIsQ0FBQTtJQUVwQyxnQ0FBZ0M7SUFDaEMsWUFBWSxPQUFPLEdBQUcseUJBQXlCO1FBQzdDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQTtRQUVkLElBQUksS0FBSyxDQUFDLGlCQUFpQjtZQUFFLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsMkJBQTJCLENBQUMsQ0FBQTtJQUN6RixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG5cbi8qKlxuICogUmFpc2VkIGJ5IHRoZSBjb21tYW5kcyBwb29sIHdoZW4gYSByZXF1ZXN0IGNvdWxkIG5vdCBydW4gYmVjYXVzZSB0aGUgc2Vzc2lvblxuICogaGFkIGV4cGlyZWQgKHRoZSBmcm9udGVuZCdzIGJlbGlldmVkIHVzZXIgZGl2ZXJnZWQgZnJvbSB0aGUgYmFja2VuZCdzIGFjdHVhbFxuICogdXNlcikgYW5kIGNvdWxkIG5vdCBiZSByZW5ld2VkLiBDYWxsZXJzIGNhbiB0cmVhdCB0aGlzIGFzIGEgYmVuaWduIFwicGxlYXNlXG4gKiBzaWduIGluIGFnYWluXCIgc2lnbmFsIOKAlCB0aGUgc2lnbi1pbiBmb3JtIGlzIHNob3duIGNlbnRyYWxseSB2aWEgdGhlIERldmlzZVxuICogc2lnbi1vdXQgZXZlbnQg4oCUIHJhdGhlciB0aGFuIGEgcmVhbCBjb21tYW5kIGZhaWx1cmUuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyU2Vzc2lvbkV4cGlyZWRFcnJvciBleHRlbmRzIEVycm9yIHtcbiAgc3RhdGljIGFwaU1ha2VyVHlwZSA9IFwiU2Vzc2lvbkV4cGlyZWRFcnJvclwiXG4gIGFwaU1ha2VyVHlwZSA9IFwiU2Vzc2lvbkV4cGlyZWRFcnJvclwiXG5cbiAgLyoqIEBwYXJhbSB7c3RyaW5nfSBbbWVzc2FnZV0gKi9cbiAgY29uc3RydWN0b3IobWVzc2FnZSA9IFwiVGhlIHNlc3Npb24gaGFzIGV4cGlyZWRcIikge1xuICAgIHN1cGVyKG1lc3NhZ2UpXG5cbiAgICBpZiAoRXJyb3IuY2FwdHVyZVN0YWNrVHJhY2UpIEVycm9yLmNhcHR1cmVTdGFja1RyYWNlKHRoaXMsIEFwaU1ha2VyU2Vzc2lvbkV4cGlyZWRFcnJvcilcbiAgfVxufVxuIl19

package/build/session-status-updater.d.ts

@@ -6,6 +6,7 @@
  * @typedef {object} SessionStatusResult
  * @property {string} [csrf_token]
  * @property {Record<string, SessionStatusScope>} scopes
+ * @property {string} [shadow_session_token]
  */
 /**
  * @typedef {object} SessionStatusUpdaterArgs
@@ -32,6 +33,20 @@ export default class ApiMakerSessionStatusUpdater {
     connectOnlineEvent(): void;
     /** Re-checks session state when the device wakes from sleep. */
     connectWakeEvent(): void;
+    /**
+     * Re-checks session state when the user returns to a backgrounded tab/app.
+     * The `wake-event` package only fires on multi-second device-sleep drift, so
+     * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover
+     * that, surfacing an expired session the moment the user returns.
+     */
+    connectVisibilityEvents(): void;
+    /**
+     * Schedules a debounced session-status refresh when the page becomes visible
+     * again. visibilitychange, focus and pageshow can fire together on return, so
+     * the refresh is collapsed into a single request.
+     */
+    refreshOnReturnToForeground: () => void;
+    returnRefreshTimeout: any;
     getCsrfToken(): Promise<string>;
     csrfToken: string;
     /**
@@ -79,6 +94,7 @@ export type SessionStatusScope = {
 export type SessionStatusResult = {
     csrf_token?: string;
     scopes: Record<string, SessionStatusScope>;
+    shadow_session_token?: string;
 };
 export type SessionStatusUpdaterArgs = {
     timeout?: number;

package/build/session-status-updater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-status-updater.d.ts","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;;GAIG;AAEH;;;;GAIG;AAEH,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,sBAHW,wBAAwB,GACtB,4BAA4B,CAQxC;IAED;;;OAGG;IACH,mBAFW,wBAAwB,EAmBlC;IAhBC,WAAgB;IAChB,gBAAqC;IAGnC,wBAAyC;IAc7C,kEAAkE;IAClE,2BAEC;IAED,gEAAgE;IAChE,yBAEC;IAED,gCA+BC;IAlBK,kBAAyD;IAoB/D;;;OAGG;IACH,iBAFa,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,sCAGC;IAED,6DAA6D;IAC7D,qBAaC;IAPC,8BAMC;IAGH,gEAAgE;IAChE,oBAGC;IAED,gEAAgE;IAChE,yCAMC;IAED;;;OAGG;IACH,oBAHW,mBAAmB,GACjB,IAAI,CAOhB;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAqB7B;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAM7B;IAED;;;;OAIG;IACH,4CAHW,MAAM,SACN,kBAAkB,QAkB5B;CACF;;eAnOa,OAAO;;;iBAKP,MAAM;YACN,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;;;cAKlC,MAAM;qBACN,OAAO"}
+{"version":3,"file":"session-status-updater.d.ts","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"AAYA;;;GAGG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH,+CAA+C;AAC/C;IACE;;;;OAIG;IACH,sBAHW,wBAAwB,GACtB,4BAA4B,CAQxC;IAED;;;OAGG;IACH,mBAFW,wBAAwB,EAuBlC;IApBC,WAAgB;IAChB,gBAAqC;IAGnC,wBAAyC;IAkB7C,kEAAkE;IAClE,2BAEC;IAED,gEAAgE;IAChE,yBAEC;IAED;;;;;OAKG;IACH,gCAOC;IAED;;;;OAIG;IACH,wCAWC;IAJC,0BAGM;IAGR,gCA+BC;IAlBK,kBAAyD;IAoB/D;;;OAGG;IACH,iBAFa,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,sCAGC;IAED,6DAA6D;IAC7D,qBAaC;IAPC,8BAMC;IAGH,gEAAgE;IAChE,oBAGC;IAED,gEAAgE;IAChE,yCAMC;IAED;;;OAGG;IACH,oBAHW,mBAAmB,GACjB,IAAI,CAOhB;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAqB7B;IAED;;;OAGG;IACH,qCAFW,mBAAmB,QAM7B;IAED;;;;OAIG;IACH,4CAHW,MAAM,SACN,kBAAkB,QAkB5B;CACF;;eAzQa,OAAO;;;iBAKP,MAAM;YACN,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;2BAClC,MAAM;;;cAKN,MAAM;qBACN,OAAO"}

package/build/session-status-updater.js

@@ -15,6 +15,7 @@ const shared = {};
  * @typedef {object} SessionStatusResult
  * @property {string} [csrf_token]
  * @property {Record<string, SessionStatusScope>} scopes
+ * @property {string} [shadow_session_token]
  */
 /**
  * @typedef {object} SessionStatusUpdaterArgs
@@ -53,6 +54,9 @@ export default class ApiMakerSessionStatusUpdater {
         if (typeof window != "undefined") {
             this.connectOnlineEvent();
         }
+        if (typeof document != "undefined") {
+            this.connectVisibilityEvents();
+        }
         this.connectWakeEvent();
     }
     /** Re-checks session state when the browser comes back online. */
@@ -63,6 +67,35 @@ export default class ApiMakerSessionStatusUpdater {
     connectWakeEvent() {
         wakeEvent(this.updateSessionStatus);
     }
+    /**
+     * Re-checks session state when the user returns to a backgrounded tab/app.
+     * The `wake-event` package only fires on multi-second device-sleep drift, so
+     * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover
+     * that, surfacing an expired session the moment the user returns.
+     */
+    connectVisibilityEvents() {
+        document.addEventListener("visibilitychange", this.refreshOnReturnToForeground, false);
+        if (typeof window != "undefined") {
+            window.addEventListener("focus", this.refreshOnReturnToForeground, false);
+            window.addEventListener("pageshow", this.refreshOnReturnToForeground, false);
+        }
+    }
+    /**
+     * Schedules a debounced session-status refresh when the page becomes visible
+     * again. visibilitychange, focus and pageshow can fire together on return, so
+     * the refresh is collapsed into a single request.
+     */
+    refreshOnReturnToForeground = () => {
+        if (typeof document != "undefined" && document.visibilityState && document.visibilityState != "visible") {
+            return;
+        }
+        if (this.returnRefreshTimeout)
+            return;
+        this.returnRefreshTimeout = setTimeout(() => {
+            this.returnRefreshTimeout = undefined;
+            this.updateSessionStatus();
+        }, 50);
+    };
     async getCsrfToken() {
         if (this.csrfToken) {
             logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`);
@@ -192,4 +225,4 @@ export default class ApiMakerSessionStatusUpdater {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-status-updater.js","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport Devise from \"./devise.js\"\nimport Logger from \"./logger.js\"\nimport config from \"./config.js\"\nimport wakeEvent from \"wake-event\"\n\nconst logger = new Logger({name: \"ApiMaker / SessionStatusUpdater\"})\nconst shared = {}\n\n// logger.setDebug(true)\n\n/**\n * @typedef {object} SessionStatusScope\n * @property {boolean} signed_in\n */\n\n/**\n * @typedef {object} SessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, SessionStatusScope>} scopes\n */\n\n/**\n * @typedef {object} SessionStatusUpdaterArgs\n * @property {number} [timeout]\n * @property {boolean} [useMetaElement]\n */\n\n/** Tracks session and CSRF token freshness. */\nexport default class ApiMakerSessionStatusUpdater {\n  /**\n   * Returns the shared session-status updater instance.\n   * @param {SessionStatusUpdaterArgs} [args]\n   * @returns {ApiMakerSessionStatusUpdater}\n   */\n  static current(args) {\n    if (!shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater(args)\n    }\n\n    return shared.apiMakerSessionStatusUpdater\n  }\n\n  /**\n   * Sets up session-status polling and browser wake/online listeners.\n   * @param {SessionStatusUpdaterArgs} [args]\n   */\n  constructor(args = {}) {\n    this.events = {}\n    this.timeout = args.timeout || 600000\n\n    if (\"useMetaElement\" in args) {\n      this.useMetaElement = args.useMetaElement\n    } else if (typeof document === \"undefined\") {\n      this.useMetaElement = false\n    } else {\n      this.useMetaElement = true\n    }\n\n    if (typeof window != \"undefined\") {\n      this.connectOnlineEvent()\n    }\n\n    this.connectWakeEvent()\n  }\n\n  /** Re-checks session state when the browser comes back online. */\n  connectOnlineEvent() {\n    window.addEventListener(\"online\", this.updateSessionStatus, false)\n  }\n\n  /** Re-checks session state when the device wakes from sleep. */\n  connectWakeEvent() {\n    wakeEvent(this.updateSessionStatus)\n  }\n\n  async getCsrfToken() {\n    if (this.csrfToken) {\n      logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Get CSRF token from meta element: ${csrfTokenElement.getAttribute(\"content\")}`)\n\n        this.csrfToken = csrfTokenElement.getAttribute(\"content\")\n\n        return this.csrfToken\n      }\n    }\n\n    logger.debug(\"Updating session status because no CSRF token set yet\")\n    await this.updateSessionStatus()\n\n    if (this.csrfToken) {\n      logger.debug(() => `Returning CSRF token after updating session status: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    logger.debug(\"No CSRF token available after updating session status\")\n\n    return undefined\n  }\n\n  /**\n   * Requests the latest backend session-status payload.\n   * @returns {Promise<SessionStatusResult>}\n   */\n  sessionStatus() {\n    return new Promise((resolve) => {\n      const host = config.getHost()\n      let requestPath = \"\"\n\n      if (host) requestPath += host\n\n      requestPath += \"/api_maker/session_statuses\"\n\n      const xhr = new XMLHttpRequest()\n      xhr.open(\"POST\", requestPath, true)\n      xhr.onload = () => {\n        const response = JSON.parse(xhr.responseText)\n        resolve(response)\n      }\n      xhr.send()\n    })\n  }\n\n  /**\n   * Registers a callback for frontend sign-out detection.\n   * @param {Function} callback\n   */\n  onSignedOut(callback) {\n    // @ts-expect-error\n    this.addEvent(\"onSignedOut\", callback)\n  }\n\n  /** Starts or refreshes the periodic session-status timer. */\n  startTimeout() {\n    logger.debug(\"startTimeout\")\n\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n\n    this.updateTimeout = setTimeout(\n      () => {\n        this.startTimeout()\n        this.updateSessionStatus()\n      },\n      this.timeout\n    )\n  }\n\n  /** Stops the periodic session-status timer if it is running. */\n  stopTimeout() {\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n  }\n\n  /** Fetches the latest session status and applies it locally. */\n  updateSessionStatus = async () => {\n    logger.debug(\"updateSessionStatus\")\n\n    const result = await this.sessionStatus()\n\n    this.applyResult(result)\n  }\n\n  /**\n   * @param {SessionStatusResult} result\n   * @returns {void}\n   */\n  applyResult(result) {\n    logger.debug(() => `Result: ${JSON.stringify(result, null, 2)}`)\n\n    this.updateMetaElementsFromResult(result)\n    this.updateUserSessionsFromResult(result)\n  }\n\n  /**\n   * Updates the cached and DOM CSRF token from one session-status response.\n   * @param {SessionStatusResult} result\n   */\n  updateMetaElementsFromResult(result) {\n    logger.debug(\"updateMetaElementsFromResult\")\n\n    if (!result.csrf_token) {\n      return\n    }\n\n    this.csrfToken = result.csrf_token\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Changing token from \"${csrfTokenElement.getAttribute(\"content\")}\" to \"${result.csrf_token}\"`)\n        csrfTokenElement.setAttribute(\"content\", result.csrf_token)\n      } else {\n        logger.debug(\"csrf token element couldn't be found\")\n      }\n    }\n  }\n\n  /**\n   * Applies each returned scope status to the frontend Devise cache.\n   * @param {SessionStatusResult} result\n   */\n  updateUserSessionsFromResult(result) {\n    for (const scopeName in result.scopes) {\n      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])\n    }\n  }\n\n  /**\n   * Applies one scope's signed-in state to the frontend Devise cache.\n   * @param {string} scopeName\n   * @param {SessionStatusScope} scope\n   */\n  updateUserSessionScopeFromResult(scopeName, scope) {\n    const deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`\n\n    if (!(deviseIsSignedInMethodName in Devise)) {\n      throw new Error(`No such method in Devise: ${deviseIsSignedInMethodName}`)\n    }\n\n    const currentlySignedIn = Devise[deviseIsSignedInMethodName]()\n    const signedInOnBackend = scope.signed_in\n\n    if (currentlySignedIn && !signedInOnBackend) {\n      logger.debug(() => `${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)\n\n      Devise.setSignedOut({scope: scopeName})\n      Devise.callSignOutEvent({scope: scopeName})\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"session-status-updater.js","sourceRoot":"/src/","sources":["session-status-updater.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\nimport * as inflection from \"inflection\"\nimport Devise from \"./devise.js\"\nimport Logger from \"./logger.js\"\nimport config from \"./config.js\"\nimport wakeEvent from \"wake-event\"\n\nconst logger = new Logger({name: \"ApiMaker / SessionStatusUpdater\"})\nconst shared = {}\n\n// logger.setDebug(true)\n\n/**\n * @typedef {object} SessionStatusScope\n * @property {boolean} signed_in\n */\n\n/**\n * @typedef {object} SessionStatusResult\n * @property {string} [csrf_token]\n * @property {Record<string, SessionStatusScope>} scopes\n * @property {string} [shadow_session_token]\n */\n\n/**\n * @typedef {object} SessionStatusUpdaterArgs\n * @property {number} [timeout]\n * @property {boolean} [useMetaElement]\n */\n\n/** Tracks session and CSRF token freshness. */\nexport default class ApiMakerSessionStatusUpdater {\n  /**\n   * Returns the shared session-status updater instance.\n   * @param {SessionStatusUpdaterArgs} [args]\n   * @returns {ApiMakerSessionStatusUpdater}\n   */\n  static current(args) {\n    if (!shared.apiMakerSessionStatusUpdater) {\n      shared.apiMakerSessionStatusUpdater = new ApiMakerSessionStatusUpdater(args)\n    }\n\n    return shared.apiMakerSessionStatusUpdater\n  }\n\n  /**\n   * Sets up session-status polling and browser wake/online listeners.\n   * @param {SessionStatusUpdaterArgs} [args]\n   */\n  constructor(args = {}) {\n    this.events = {}\n    this.timeout = args.timeout || 600000\n\n    if (\"useMetaElement\" in args) {\n      this.useMetaElement = args.useMetaElement\n    } else if (typeof document === \"undefined\") {\n      this.useMetaElement = false\n    } else {\n      this.useMetaElement = true\n    }\n\n    if (typeof window != \"undefined\") {\n      this.connectOnlineEvent()\n    }\n\n    if (typeof document != \"undefined\") {\n      this.connectVisibilityEvents()\n    }\n\n    this.connectWakeEvent()\n  }\n\n  /** Re-checks session state when the browser comes back online. */\n  connectOnlineEvent() {\n    window.addEventListener(\"online\", this.updateSessionStatus, false)\n  }\n\n  /** Re-checks session state when the device wakes from sleep. */\n  connectWakeEvent() {\n    wakeEvent(this.updateSessionStatus)\n  }\n\n  /**\n   * Re-checks session state when the user returns to a backgrounded tab/app.\n   * The `wake-event` package only fires on multi-second device-sleep drift, so\n   * it misses iOS Safari tab suspension; visibilitychange/focus/pageshow cover\n   * that, surfacing an expired session the moment the user returns.\n   */\n  connectVisibilityEvents() {\n    document.addEventListener(\"visibilitychange\", this.refreshOnReturnToForeground, false)\n\n    if (typeof window != \"undefined\") {\n      window.addEventListener(\"focus\", this.refreshOnReturnToForeground, false)\n      window.addEventListener(\"pageshow\", this.refreshOnReturnToForeground, false)\n    }\n  }\n\n  /**\n   * Schedules a debounced session-status refresh when the page becomes visible\n   * again. visibilitychange, focus and pageshow can fire together on return, so\n   * the refresh is collapsed into a single request.\n   */\n  refreshOnReturnToForeground = () => {\n    if (typeof document != \"undefined\" && document.visibilityState && document.visibilityState != \"visible\") {\n      return\n    }\n\n    if (this.returnRefreshTimeout) return\n\n    this.returnRefreshTimeout = setTimeout(() => {\n      this.returnRefreshTimeout = undefined\n      this.updateSessionStatus()\n    }, 50)\n  }\n\n  async getCsrfToken() {\n    if (this.csrfToken) {\n      logger.debug(`Get CSRF token from set variable: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Get CSRF token from meta element: ${csrfTokenElement.getAttribute(\"content\")}`)\n\n        this.csrfToken = csrfTokenElement.getAttribute(\"content\")\n\n        return this.csrfToken\n      }\n    }\n\n    logger.debug(\"Updating session status because no CSRF token set yet\")\n    await this.updateSessionStatus()\n\n    if (this.csrfToken) {\n      logger.debug(() => `Returning CSRF token after updating session status: ${this.csrfToken}`)\n\n      return this.csrfToken\n    }\n\n    logger.debug(\"No CSRF token available after updating session status\")\n\n    return undefined\n  }\n\n  /**\n   * Requests the latest backend session-status payload.\n   * @returns {Promise<SessionStatusResult>}\n   */\n  sessionStatus() {\n    return new Promise((resolve) => {\n      const host = config.getHost()\n      let requestPath = \"\"\n\n      if (host) requestPath += host\n\n      requestPath += \"/api_maker/session_statuses\"\n\n      const xhr = new XMLHttpRequest()\n      xhr.open(\"POST\", requestPath, true)\n      xhr.onload = () => {\n        const response = JSON.parse(xhr.responseText)\n        resolve(response)\n      }\n      xhr.send()\n    })\n  }\n\n  /**\n   * Registers a callback for frontend sign-out detection.\n   * @param {Function} callback\n   */\n  onSignedOut(callback) {\n    // @ts-expect-error\n    this.addEvent(\"onSignedOut\", callback)\n  }\n\n  /** Starts or refreshes the periodic session-status timer. */\n  startTimeout() {\n    logger.debug(\"startTimeout\")\n\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n\n    this.updateTimeout = setTimeout(\n      () => {\n        this.startTimeout()\n        this.updateSessionStatus()\n      },\n      this.timeout\n    )\n  }\n\n  /** Stops the periodic session-status timer if it is running. */\n  stopTimeout() {\n    if (this.updateTimeout)\n      clearTimeout(this.updateTimeout)\n  }\n\n  /** Fetches the latest session status and applies it locally. */\n  updateSessionStatus = async () => {\n    logger.debug(\"updateSessionStatus\")\n\n    const result = await this.sessionStatus()\n\n    this.applyResult(result)\n  }\n\n  /**\n   * @param {SessionStatusResult} result\n   * @returns {void}\n   */\n  applyResult(result) {\n    logger.debug(() => `Result: ${JSON.stringify(result, null, 2)}`)\n\n    this.updateMetaElementsFromResult(result)\n    this.updateUserSessionsFromResult(result)\n  }\n\n  /**\n   * Updates the cached and DOM CSRF token from one session-status response.\n   * @param {SessionStatusResult} result\n   */\n  updateMetaElementsFromResult(result) {\n    logger.debug(\"updateMetaElementsFromResult\")\n\n    if (!result.csrf_token) {\n      return\n    }\n\n    this.csrfToken = result.csrf_token\n\n    if (this.useMetaElement) {\n      const csrfTokenElement = document.querySelector(\"meta[name='csrf-token']\")\n\n      if (csrfTokenElement) {\n        logger.debug(() => `Changing token from \"${csrfTokenElement.getAttribute(\"content\")}\" to \"${result.csrf_token}\"`)\n        csrfTokenElement.setAttribute(\"content\", result.csrf_token)\n      } else {\n        logger.debug(\"csrf token element couldn't be found\")\n      }\n    }\n  }\n\n  /**\n   * Applies each returned scope status to the frontend Devise cache.\n   * @param {SessionStatusResult} result\n   */\n  updateUserSessionsFromResult(result) {\n    for (const scopeName in result.scopes) {\n      this.updateUserSessionScopeFromResult(scopeName, result.scopes[scopeName])\n    }\n  }\n\n  /**\n   * Applies one scope's signed-in state to the frontend Devise cache.\n   * @param {string} scopeName\n   * @param {SessionStatusScope} scope\n   */\n  updateUserSessionScopeFromResult(scopeName, scope) {\n    const deviseIsSignedInMethodName = `is${inflection.camelize(scopeName)}SignedIn`\n\n    if (!(deviseIsSignedInMethodName in Devise)) {\n      throw new Error(`No such method in Devise: ${deviseIsSignedInMethodName}`)\n    }\n\n    const currentlySignedIn = Devise[deviseIsSignedInMethodName]()\n    const signedInOnBackend = scope.signed_in\n\n    if (currentlySignedIn && !signedInOnBackend) {\n      logger.debug(() => `${inflection.camelize(scopeName)} signed in on frontend but not in backend!`)\n\n      Devise.setSignedOut({scope: scopeName})\n      Devise.callSignOutEvent({scope: scopeName})\n    }\n  }\n}\n"]}

package/build/table/export/cell-value.d.ts

@@ -0,0 +1,3 @@
+export function cellToText(value: unknown): string;
+export function cellToHtml(value: unknown): string;
+//# sourceMappingURL=cell-value.d.ts.map

package/build/table/export/cell-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cell-value.d.ts","sourceRoot":"/src/","sources":["table/export/cell-value.js"],"names":[],"mappings":"AAwCO,kCAHI,OAAO,GACL,MAAM,CAEwF;AAOpG,kCAHI,OAAO,GACL,MAAM,CAE+C"}

package/build/table/export/cell-value.js

@@ -0,0 +1,47 @@
+// @ts-check
+/* eslint-disable sort-imports */
+import React from "react";
+/**
+ * @param {unknown} value
+ * @returns {string}
+ */
+const toText = (value) => (value === null || value === undefined ? "" : String(value));
+/**
+ * Recursively extracts the text content of a React node without rendering it, so the export path stays
+ * lightweight and SSR-/test-safe (no react-dom/server). A column's custom `content` can return a React
+ * element even in "html" mode; this keeps such cells exporting their text instead of "[object Object]".
+ * @param {unknown} node
+ * @returns {string}
+ */
+const reactNodeToText = (node) => {
+    if (node === null || node === undefined || typeof node === "boolean")
+        return "";
+    if (typeof node === "string" || typeof node === "number")
+        return String(node);
+    if (Array.isArray(node))
+        return node.map(reactNodeToText).join("");
+    if (React.isValidElement(node))
+        return reactNodeToText(/** @type {{props?: {children?: unknown}}} */ (node).props?.children);
+    return "";
+};
+/**
+ * @param {string} text
+ * @returns {string}
+ */
+const escapeHtml = (text) => text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+/**
+ * Plain text value of a cell, for CSV/Excel.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export const cellToText = (value) => (React.isValidElement(value) ? reactNodeToText(value) : toText(value));
+/**
+ * HTML-escaped text value of a cell, for the HTML export.
+ * @param {unknown} value
+ * @returns {string}
+ */
+export const cellToHtml = (value) => escapeHtml(cellToText(value));
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/file-sinks/web-file-sink.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @typedef {object} ExportFileSink
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsWritableStream
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsFileHandle
+ * @property {() => Promise<FsWritableStream>} createWritable
+ */
+/**
+ * @typedef {object} FsWindow
+ * @property {(options: object) => Promise<FsFileHandle>} [showSaveFilePicker]
+ */
+/**
+ * Opens a streaming file sink in the browser. When the File System Access API is available (Chromium), the
+ * export is written straight to the user-chosen file so memory stays bounded. Otherwise it falls back to
+ * buffering the chunks and saving a Blob via file-saver (memory-bound, but works everywhere).
+ *
+ * Must be called from within a user-gesture handler so the save-file picker is allowed to open.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @returns {Promise<ExportFileSink>}
+ */
+export default function openWebFileSink({ fileName, mimeType }: {
+    fileName: string;
+    mimeType: string;
+}): Promise<ExportFileSink>;
+export type ExportFileSink = {
+    write: (chunk: string | Uint8Array) => Promise<void>;
+    close: () => Promise<void>;
+    abort: () => Promise<void>;
+};
+export type FsWritableStream = {
+    write: (chunk: string | Uint8Array) => Promise<void>;
+    close: () => Promise<void>;
+    abort: () => Promise<void>;
+};
+export type FsFileHandle = {
+    createWritable: () => Promise<FsWritableStream>;
+};
+export type FsWindow = {
+    showSaveFilePicker?: (options: object) => Promise<FsFileHandle>;
+};
+//# sourceMappingURL=web-file-sink.d.ts.map

package/build/table/export/file-sinks/web-file-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-file-sink.d.ts","sourceRoot":"/src/","sources":["table/export/file-sinks/web-file-sink.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH;;;;;GAKG;AACH;;;GAGG;AACH;;;GAGG;AAEH;;;;;;;;;;;GAWG;AACH,gEAJG;IAAqB,QAAQ,EAArB,MAAM;IACO,QAAQ,EAArB,MAAM;CACd,GAAU,OAAO,CAAC,cAAc,CAAC,CAgDnC;;WA7Ea,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;WAC7C,MAAM,OAAO,CAAC,IAAI,CAAC;WACnB,MAAM,OAAO,CAAC,IAAI,CAAC;;;WAInB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC;WAC7C,MAAM,OAAO,CAAC,IAAI,CAAC;WACnB,MAAM,OAAO,CAAC,IAAI,CAAC;;;oBAInB,MAAM,OAAO,CAAC,gBAAgB,CAAC;;;yBAI/B,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC"}

package/build/table/export/file-sinks/web-file-sink.js

@@ -0,0 +1,75 @@
+// @ts-check
+import { saveAs } from "file-saver";
+/**
+ * @typedef {object} ExportFileSink
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsWritableStream
+ * @property {(chunk: string | Uint8Array) => Promise<void>} write
+ * @property {() => Promise<void>} close
+ * @property {() => Promise<void>} abort
+ */
+/**
+ * @typedef {object} FsFileHandle
+ * @property {() => Promise<FsWritableStream>} createWritable
+ */
+/**
+ * @typedef {object} FsWindow
+ * @property {(options: object) => Promise<FsFileHandle>} [showSaveFilePicker]
+ */
+/**
+ * Opens a streaming file sink in the browser. When the File System Access API is available (Chromium), the
+ * export is written straight to the user-chosen file so memory stays bounded. Otherwise it falls back to
+ * buffering the chunks and saving a Blob via file-saver (memory-bound, but works everywhere).
+ *
+ * Must be called from within a user-gesture handler so the save-file picker is allowed to open.
+ *
+ * @param {object} args
+ * @param {string} args.fileName
+ * @param {string} args.mimeType
+ * @returns {Promise<ExportFileSink>}
+ */
+export default async function openWebFileSink({ fileName, mimeType }) {
+    const win = /** @type {FsWindow | undefined} */ (typeof window === "undefined" ? undefined : /** @type {unknown} */ (window));
+    if (win && typeof win.showSaveFilePicker === "function") {
+        const extension = fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".")) : "";
+        try {
+            const handle = await win.showSaveFilePicker({
+                suggestedName: fileName,
+                types: extension ? [{ accept: { [mimeType]: [extension] } }] : undefined
+            });
+            const writable = await handle.createWritable();
+            return {
+                write: (chunk) => writable.write(chunk),
+                close: () => writable.close(),
+                abort: () => writable.abort()
+            };
+        }
+        catch (error) {
+            // The user cancelled the picker - propagate so the export aborts quietly.
+            if (error && /** @type {Error} */ (error).name === "AbortError")
+                throw error;
+            // Any other problem (e.g. picker not usable in this context): fall back to the Blob path below.
+        }
+    }
+    /** @type {Array<string | Uint8Array>} */
+    const chunks = [];
+    return {
+        write: (chunk) => {
+            chunks.push(chunk);
+            return Promise.resolve();
+        },
+        close: () => {
+            saveAs(new Blob(chunks, { type: mimeType }), fileName);
+            return Promise.resolve();
+        },
+        abort: () => {
+            chunks.length = 0;
+            return Promise.resolve();
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/csv-writer.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Streaming CSV writer. Emits one chunk per call so the export driver can write each page straight to the
+ * file sink without holding the whole document in memory. RFC-4180 quoting, CRLF line breaks, and a UTF-8 BOM
+ * so Excel opens it with the right encoding.
+ */
+export default class ApiMakerTableExportCsvWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels: Array<string>): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values: Array<unknown>): string;
+    /** @returns {string} */
+    footer(): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    line(values: Array<unknown>): string;
+    /**
+     * @param {unknown} value
+     * @returns {string}
+     */
+    escape(value: unknown): string;
+}
+//# sourceMappingURL=csv-writer.d.ts.map

package/build/table/export/format-writers/csv-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/csv-writer.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH;IACE;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAIlB;IAED,wBAAwB;IACxB,UADc,MAAM,CAGnB;IAED;;;OAGG;IACH,aAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,OAAO,GACL,MAAM,CAUlB;CACF"}

package/build/table/export/format-writers/csv-writer.js

@@ -0,0 +1,47 @@
+// @ts-check
+import { cellToText } from "../cell-value.js";
+const UTF8_BOM = "";
+/**
+ * Streaming CSV writer. Emits one chunk per call so the export driver can write each page straight to the
+ * file sink without holding the whole document in memory. RFC-4180 quoting, CRLF line breaks, and a UTF-8 BOM
+ * so Excel opens it with the right encoding.
+ */
+export default class ApiMakerTableExportCsvWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels) {
+        return UTF8_BOM + this.line(labels);
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values) {
+        return this.line(values);
+    }
+    /** @returns {string} */
+    footer() {
+        return "";
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    line(values) {
+        return `${values.map((value) => this.escape(value)).join(",")}\r\n`;
+    }
+    /**
+     * @param {unknown} value
+     * @returns {string}
+     */
+    escape(value) {
+        const text = cellToText(value);
+        if ((/["\r\n,]/).test(text)) {
+            return `"${text.replace(/"/g, "\"\"")}"`;
+        }
+        return text;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/html-writer.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Streaming HTML-table writer. Emits the table head, one `<tr>` per row, and the closing tags as separate
+ * chunks so the export driver can write each page to the file sink incrementally. Cells that are React
+ * elements (from a column's custom `content`) are rendered to markup; other values are escaped text.
+ */
+export default class ApiMakerTableExportHtmlWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels: Array<string>): string;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values: Array<unknown>): string;
+    /** @returns {string} */
+    footer(): string;
+}
+//# sourceMappingURL=html-writer.d.ts.map

package/build/table/export/format-writers/html-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/html-writer.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IACE;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,MAAM,CAMlB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,MAAM,CAMlB;IAED,wBAAwB;IACxB,UADc,MAAM,CAGnB;CACF"}

package/build/table/export/format-writers/html-writer.js

@@ -0,0 +1,30 @@
+// @ts-check
+import { cellToHtml } from "../cell-value.js";
+/**
+ * Streaming HTML-table writer. Emits the table head, one `<tr>` per row, and the closing tags as separate
+ * chunks so the export driver can write each page to the file sink incrementally. Cells that are React
+ * elements (from a column's custom `content`) are rendered to markup; other values are escaped text.
+ */
+export default class ApiMakerTableExportHtmlWriter {
+    /**
+     * @param {Array<string>} labels
+     * @returns {string}
+     */
+    header(labels) {
+        const cells = labels.map((label) => `<th>${cellToHtml(label)}</th>`).join("");
+        return `<table><thead><tr>${cells}</tr></thead><tbody>`;
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {string}
+     */
+    row(values) {
+        const cells = values.map((value) => `<td>${cellToHtml(value)}</td>`).join("");
+        return `<tr>${cells}</tr>`;
+    }
+    /** @returns {string} */
+    footer() {
+        return "</tbody></table>";
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/table/export/format-writers/xlsx-writer.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Excel (.xlsx) writer. xlsx is a zipped binary that can't be appended chunk-by-chunk, so this buffers the
+ * rows and serializes the whole workbook in `footer()`. To keep api_maker free of a heavy spreadsheet
+ * dependency, the actual serialization is provided by the host app via
+ * `apiMakerConfig.setExportXlsxSerializer(rows => Uint8Array)`. Best for moderate row counts — use CSV for
+ * very large exports.
+ */
+export default class ApiMakerTableExportXlsxWriter {
+    rows: unknown[][];
+    /**
+     * @param {Array<string>} labels
+     * @returns {null}
+     */
+    header(labels: Array<string>): null;
+    /**
+     * @param {Array<unknown>} values
+     * @returns {null}
+     */
+    row(values: Array<unknown>): null;
+    /** @returns {Promise<Uint8Array>} */
+    footer(): Promise<Uint8Array>;
+}
+//# sourceMappingURL=xlsx-writer.d.ts.map

package/build/table/export/format-writers/xlsx-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xlsx-writer.d.ts","sourceRoot":"/src/","sources":["table/export/format-writers/xlsx-writer.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH;IAEI,kBAAqD;IAGvD;;;OAGG;IACH,eAHW,KAAK,CAAC,MAAM,CAAC,GACX,IAAI,CAMhB;IAED;;;OAGG;IACH,YAHW,KAAK,CAAC,OAAO,CAAC,GACZ,IAAI,CAMhB;IAED,qCAAqC;IACrC,UADc,OAAO,CAAC,UAAU,CAAC,CAShC;CACF"}

package/build/table/export/format-writers/xlsx-writer.js

@@ -0,0 +1,41 @@
+// @ts-check
+/* eslint-disable sort-imports */
+import apiMakerConfig from "../../../config.js";
+import { cellToText } from "../cell-value.js";
+/**
+ * Excel (.xlsx) writer. xlsx is a zipped binary that can't be appended chunk-by-chunk, so this buffers the
+ * rows and serializes the whole workbook in `footer()`. To keep api_maker free of a heavy spreadsheet
+ * dependency, the actual serialization is provided by the host app via
+ * `apiMakerConfig.setExportXlsxSerializer(rows => Uint8Array)`. Best for moderate row counts — use CSV for
+ * very large exports.
+ */
+export default class ApiMakerTableExportXlsxWriter {
+    constructor() {
+        this.rows = /** @type {Array<Array<unknown>>} */ ([]);
+    }
+    /**
+     * @param {Array<string>} labels
+     * @returns {null}
+     */
+    header(labels) {
+        this.rows.push(labels);
+        return null;
+    }
+    /**
+     * @param {Array<unknown>} values
+     * @returns {null}
+     */
+    row(values) {
+        this.rows.push(values.map((value) => cellToText(value)));
+        return null;
+    }
+    /** @returns {Promise<Uint8Array>} */
+    async footer() {
+        const serializer = apiMakerConfig.getExportXlsxSerializer();
+        if (!serializer) {
+            throw new Error("Excel export isn't configured. Call apiMakerConfig.setExportXlsxSerializer(...) to enable it.");
+        }
+        return await serializer(this.rows);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoieGxzeC13cml0ZXIuanMiLCJzb3VyY2VSb290IjoiL3NyYy8iLCJzb3VyY2VzIjpbInRhYmxlL2V4cG9ydC9mb3JtYXQtd3JpdGVycy94bHN4LXdyaXRlci5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxZQUFZO0FBQ1osaUNBQWlDO0FBQ2pDLE9BQU8sY0FBYyxNQUFNLG9CQUFvQixDQUFBO0FBQy9DLE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxrQkFBa0IsQ0FBQTtBQUUzQzs7Ozs7O0dBTUc7QUFDSCxNQUFNLENBQUMsT0FBTyxPQUFPLDZCQUE2QjtJQUNoRDtRQUNFLElBQUksQ0FBQyxJQUFJLEdBQUcsb0NBQW9DLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUN2RCxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsTUFBTSxDQUFDLE1BQU07UUFDWCxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQTtRQUV0QixPQUFPLElBQUksQ0FBQTtJQUNiLENBQUM7SUFFRDs7O09BR0c7SUFDSCxHQUFHLENBQUMsTUFBTTtRQUNSLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFFeEQsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDO0lBRUQscUNBQXFDO0lBQ3JDLEtBQUssQ0FBQyxNQUFNO1FBQ1YsTUFBTSxVQUFVLEdBQUcsY0FBYyxDQUFDLHVCQUF1QixFQUFFLENBQUE7UUFFM0QsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDO1lBQ2hCLE1BQU0sSUFBSSxLQUFLLENBQUMsK0ZBQStGLENBQUMsQ0FBQTtRQUNsSCxDQUFDO1FBRUQsT0FBTyxNQUFNLFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUE7SUFDcEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLy8gQHRzLWNoZWNrXG4vKiBlc2xpbnQtZGlzYWJsZSBzb3J0LWltcG9ydHMgKi9cbmltcG9ydCBhcGlNYWtlckNvbmZpZyBmcm9tIFwiLi4vLi4vLi4vY29uZmlnLmpzXCJcbmltcG9ydCB7Y2VsbFRvVGV4dH0gZnJvbSBcIi4uL2NlbGwtdmFsdWUuanNcIlxuXG4vKipcbiAqIEV4Y2VsICgueGxzeCkgd3JpdGVyLiB4bHN4IGlzIGEgemlwcGVkIGJpbmFyeSB0aGF0IGNhbid0IGJlIGFwcGVuZGVkIGNodW5rLWJ5LWNodW5rLCBzbyB0aGlzIGJ1ZmZlcnMgdGhlXG4gKiByb3dzIGFuZCBzZXJpYWxpemVzIHRoZSB3aG9sZSB3b3JrYm9vayBpbiBgZm9vdGVyKClgLiBUbyBrZWVwIGFwaV9tYWtlciBmcmVlIG9mIGEgaGVhdnkgc3ByZWFkc2hlZXRcbiAqIGRlcGVuZGVuY3ksIHRoZSBhY3R1YWwgc2VyaWFsaXphdGlvbiBpcyBwcm92aWRlZCBieSB0aGUgaG9zdCBhcHAgdmlhXG4gKiBgYXBpTWFrZXJDb25maWcuc2V0RXhwb3J0WGxzeFNlcmlhbGl6ZXIocm93cyA9PiBVaW50OEFycmF5KWAuIEJlc3QgZm9yIG1vZGVyYXRlIHJvdyBjb3VudHMg4oCUIHVzZSBDU1YgZm9yXG4gKiB2ZXJ5IGxhcmdlIGV4cG9ydHMuXG4gKi9cbmV4cG9ydCBkZWZhdWx0IGNsYXNzIEFwaU1ha2VyVGFibGVFeHBvcnRYbHN4V3JpdGVyIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgdGhpcy5yb3dzID0gLyoqIEB0eXBlIHtBcnJheTxBcnJheTx1bmtub3duPj59ICovIChbXSlcbiAgfVxuXG4gIC8qKlxuICAgKiBAcGFyYW0ge0FycmF5PHN0cmluZz59IGxhYmVsc1xuICAgKiBAcmV0dXJucyB7bnVsbH1cbiAgICovXG4gIGhlYWRlcihsYWJlbHMpIHtcbiAgICB0aGlzLnJvd3MucHVzaChsYWJlbHMpXG5cbiAgICByZXR1cm4gbnVsbFxuICB9XG5cbiAgLyoqXG4gICAqIEBwYXJhbSB7QXJyYXk8dW5rbm93bj59IHZhbHVlc1xuICAgKiBAcmV0dXJucyB7bnVsbH1cbiAgICovXG4gIHJvdyh2YWx1ZXMpIHtcbiAgICB0aGlzLnJvd3MucHVzaCh2YWx1ZXMubWFwKCh2YWx1ZSkgPT4gY2VsbFRvVGV4dCh2YWx1ZSkpKVxuXG4gICAgcmV0dXJuIG51bGxcbiAgfVxuXG4gIC8qKiBAcmV0dXJucyB7UHJvbWlzZTxVaW50OEFycmF5Pn0gKi9cbiAgYXN5bmMgZm9vdGVyKCkge1xuICAgIGNvbnN0IHNlcmlhbGl6ZXIgPSBhcGlNYWtlckNvbmZpZy5nZXRFeHBvcnRYbHN4U2VyaWFsaXplcigpXG5cbiAgICBpZiAoIXNlcmlhbGl6ZXIpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIkV4Y2VsIGV4cG9ydCBpc24ndCBjb25maWd1cmVkLiBDYWxsIGFwaU1ha2VyQ29uZmlnLnNldEV4cG9ydFhsc3hTZXJpYWxpemVyKC4uLikgdG8gZW5hYmxlIGl0LlwiKVxuICAgIH1cblxuICAgIHJldHVybiBhd2FpdCBzZXJpYWxpemVyKHRoaXMucm93cylcbiAgfVxufVxuIl19