@dereekb/browser 13.2.2 → 13.3.1

package/index.cjs.js

@@ -6,13 +6,11 @@ var rxjs = require('rxjs');
 
 /**
  * Creatse a new BrowserObjectURLRef.
- */
-function browserObjectUrlRef() {
-    let browserUrl;
+ */ function browserObjectUrlRef() {
+    var browserUrl;
     /**
      * Revokes the existing browser object URL, if one exists.
-     */
-    function destroy() {
+     */ function destroy() {
         if (browserUrl) {
             URL.revokeObjectURL(browserUrl);
         }
@@ -25,128 +23,386 @@ function browserObjectUrlRef() {
         return browserUrl;
     }
     return {
-        destroy,
-        getBrowserUrl: () => browserUrl,
+        destroy: destroy,
+        getBrowserUrl: function getBrowserUrl() {
+            return browserUrl;
+        },
         createBrowserUrl: createBrowserUrl
     };
 }
 
-/*eslint @typescript-eslint/no-explicit-any:"off"*/
-// any is used with intent here. Proper typing with Window requires using the dynamic strings _windowKey and _callbackKey.
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Used for loading services in the browser that are imported from other scripts, such as Facebook, Segment, Stripe, etc.
- */
-class AbstractAsyncWindowLoadedService {
-    _loading = new rxjs.BehaviorSubject(undefined);
-    /**
+ */ var AbstractAsyncWindowLoadedService = /*#__PURE__*/ function() {
+    function AbstractAsyncWindowLoadedService(windowKey, callbackKey, serviceName, preload) {
+        var _this = this;
+        _class_call_check(this, AbstractAsyncWindowLoadedService);
+        _define_property(this, "_loading", new rxjs.BehaviorSubject(undefined));
+        /**
      * Key that is attached to the window for the object that is the service when finished loading.
-     */
-    _windowKey;
-    /**
+     */ _define_property(this, "_windowKey", void 0);
+        /**
      * Optional key attached to window that is a function that is executed when the setup is complete.
-     */
-    _callbackKey;
-    /**
+     */ _define_property(this, "_callbackKey", void 0);
+        /**
      * Service name used in logging. Defaults to the windowKey.
-     */
-    _serviceName;
-    loading$ = this._loading.pipe(rxjs$1.tapFirst(() => this.loadService()), rxjs$1.filterMaybe(), rxjs.shareReplay(1));
-    service$ = this.loading$.pipe(rxjs.switchMap((x) => rxjs.from(x)), rxjs.shareReplay(1));
-    /**
-     * @param windowKey
-     * @param callbackKey
-     */
-    constructor(windowKey, callbackKey, serviceName, preload) {
+     */ _define_property(this, "_serviceName", void 0);
+        /**
+     * Observable that emits the loading promise. Subscribing triggers the initial load if not already started.
+     */ _define_property(this, "loading$", this._loading.pipe(rxjs$1.tapFirst(function() {
+            return _this.loadService();
+        }), rxjs$1.filterMaybe(), rxjs.shareReplay(1)));
+        /**
+     * Observable that emits the resolved service instance once loading completes. Replays the last value to new subscribers.
+     */ _define_property(this, "service$", this.loading$.pipe(rxjs.switchMap(function(x) {
+            return rxjs.from(x);
+        }), rxjs.shareReplay(1)));
         this._windowKey = windowKey;
         this._callbackKey = callbackKey;
-        this._serviceName = serviceName ?? windowKey;
+        this._serviceName = serviceName !== null && serviceName !== void 0 ? serviceName : windowKey;
         if (util.stringToBoolean(preload)) {
             // Begin loading the service immediately.
-            setTimeout(() => this.loadService().catch());
-        }
-    }
-    destroy() {
-        this._loading.complete();
-    }
-    getService() {
-        return rxjs.firstValueFrom(this.service$);
-    }
-    // MARK: Loading
-    loadService() {
-        if (!this._loading.value) {
-            const loadingPromise = new Promise((resolve, reject) => {
-                let loadTry = 0;
-                const rejectWithError = () => {
-                    reject(new Error(`Service "${this._serviceName}" failed loading with windowKey "${this._windowKey}"`));
-                };
-                const tryLoad = () => {
-                    const windowRef = window;
-                    // Loaded before the promise.
-                    if (windowRef[this._windowKey]) {
-                        // Not yet finished loading async. Intercept the function.
-                        // console.log('Window key.');
-                        return resolve(this.completeLoadingService());
-                    }
-                    else if (this._callbackKey && windowRef[this._callbackKey]) {
-                        // console.log('Callback key.');
-                        windowRef[this._callbackKey] = () => resolve(this.completeLoadingService());
-                    }
-                    else if (loadTry < 10) {
-                        loadTry += 1;
-                        // console.log('Try reload...');
-                        setTimeout(() => tryLoad(), 1000);
-                    }
-                    else {
-                        const retry = this._onLoadServiceFailure();
-                        if (retry) {
-                            retry.then((x) => resolve(x)).catch(() => rejectWithError());
-                        }
-                        else {
-                            rejectWithError();
-                        }
-                    }
-                };
-                tryLoad();
+            setTimeout(function() {
+                return _this.loadService().catch();
             });
-            this._loading.next(loadingPromise);
         }
-        return this._loading.value;
     }
-    _onLoadServiceFailure() {
-        // override in parent if needed.
-    }
-    async completeLoadingService() {
-        await this._prepareCompleteLoadingService();
-        const service = window[this._windowKey];
-        if (!service) {
-            throw new Error(`Service "${this._serviceName}" could not complete loading.`);
+    _create_class(AbstractAsyncWindowLoadedService, [
+        {
+            /**
+     * Completes the internal loading subject, stopping any pending service resolution.
+     */ key: "destroy",
+            value: function destroy() {
+                this._loading.complete();
+            }
+        },
+        {
+            /**
+     * Returns a promise that resolves with the loaded service instance.
+     *
+     * Triggers loading if not already started.
+     */ key: "getService",
+            value: function getService() {
+                return rxjs.firstValueFrom(this.service$);
+            }
+        },
+        {
+            // MARK: Loading
+            /**
+     * Initiates the service loading process by polling the `window` object for the service key.
+     *
+     * Retries up to 10 times at 1-second intervals before invoking `_onLoadServiceFailure()`.
+     * Subsequent calls return the same promise without re-initiating.
+     *
+     * @returns Promise that resolves with the loaded service
+     */ key: "loadService",
+            value: function loadService() {
+                var _this = this;
+                if (!this._loading.value) {
+                    var loadingPromise = new Promise(function(resolve, reject) {
+                        var loadTry = 0;
+                        var rejectWithError = function rejectWithError() {
+                            reject(new Error('Service "'.concat(_this._serviceName, '" failed loading with windowKey "').concat(_this._windowKey, '"')));
+                        };
+                        var tryLoad = function tryLoad1() {
+                            var windowRef = window;
+                            // Loaded before the promise.
+                            if (windowRef[_this._windowKey]) {
+                                // Not yet finished loading async. Intercept the function.
+                                // console.log('Window key.');
+                                return resolve(_this.completeLoadingService());
+                            } else if (_this._callbackKey && windowRef[_this._callbackKey]) {
+                                // console.log('Callback key.');
+                                windowRef[_this._callbackKey] = function() {
+                                    return resolve(_this.completeLoadingService());
+                                };
+                            } else if (loadTry < 10) {
+                                loadTry += 1;
+                                // console.log('Try reload...');
+                                setTimeout(function() {
+                                    return tryLoad();
+                                }, 1000);
+                            } else {
+                                var retry = _this._onLoadServiceFailure();
+                                if (retry) {
+                                    retry.then(function(x) {
+                                        return resolve(x);
+                                    }).catch(function() {
+                                        return rejectWithError();
+                                    });
+                                } else {
+                                    rejectWithError();
+                                }
+                            }
+                        };
+                        tryLoad();
+                    });
+                    this._loading.next(loadingPromise);
+                }
+                return this._loading.value;
+            }
+        },
+        {
+            /**
+     * Hook called when the service fails to load after all retry attempts.
+     *
+     * Subclasses can override to attempt an alternative loading strategy or return a fallback promise.
+     *
+     * @returns A promise resolving with the service if recovery succeeds, or `void` to reject
+     */ key: "_onLoadServiceFailure",
+            value: function _onLoadServiceFailure() {
+            // override in parent if needed.
+            }
+        },
+        {
+            key: "completeLoadingService",
+            value: function completeLoadingService() {
+                return _async_to_generator(function() {
+                    var service, initializedService;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this._prepareCompleteLoadingService()
+                                ];
+                            case 1:
+                                _state.sent();
+                                service = window[this._windowKey];
+                                if (!service) {
+                                    throw new Error('Service "'.concat(this._serviceName, '" could not complete loading.'));
+                                }
+                                return [
+                                    4,
+                                    this._initService(service)
+                                ];
+                            case 2:
+                                initializedService = _state.sent();
+                                return [
+                                    2,
+                                    initializedService !== null && initializedService !== void 0 ? initializedService : service
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            /**
+     * Hook called before completing the service load. Subclasses can override to perform
+     * additional async setup before the service reference is read from `window`.
+     */ key: "_prepareCompleteLoadingService",
+            value: function _prepareCompleteLoadingService() {
+                return Promise.resolve();
+            }
+        },
+        {
+            /**
+     * Hook called after the service is retrieved from `window` to perform initialization.
+     *
+     * Subclasses can override to configure or wrap the service before it is emitted to subscribers.
+     *
+     * @param service - The raw service instance from the window
+     * @returns The initialized service, or void to use the original
+     */ key: "_initService",
+            value: function _initService(service) {
+                return Promise.resolve(service);
+            }
         }
-        // Init the API
-        const initializedService = await this._initService(service);
-        return initializedService ?? service;
-    }
-    _prepareCompleteLoadingService() {
-        return Promise.resolve();
-    }
-    _initService(service) {
-        return Promise.resolve(service);
-    }
-}
+    ]);
+    return AbstractAsyncWindowLoadedService;
+} 
+();
 
 // https://dev.to/maciejtrzcinski/100vh-problem-with-ios-safari-3ge9
-const DEFAULT_VH100_VARIABLE_NAME = 'vh100';
-function refreshVh100Function(cssVariableName = DEFAULT_VH100_VARIABLE_NAME) {
-    const cssProperty = `--${cssVariableName}`;
-    return () => {
-        const doc = document.documentElement;
-        doc.style.setProperty(cssProperty, `${window.innerHeight}px`);
+/**
+ * Default CSS custom property name used to store the viewport height value.
+ */ var DEFAULT_VH100_VARIABLE_NAME = 'vh100';
+/**
+ * Creates a function that sets a CSS custom property on `document.documentElement` to the current `window.innerHeight` in pixels.
+ *
+ * This is a workaround for the iOS Safari 100vh bug where `100vh` includes the browser chrome,
+ * causing layout overflow. The returned function can be called to refresh the property value.
+ *
+ * @param cssVariableName - Name of the CSS custom property (without the `--` prefix)
+ * @returns A zero-argument function that updates the CSS property to the current inner height
+ *
+ * @example
+ * ```typescript
+ * const refresh = refreshVh100Function('vh100');
+ * refresh(); // sets --vh100 to e.g. "812px"
+ * ```
+ */ function refreshVh100Function() {
+    var cssVariableName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_VH100_VARIABLE_NAME;
+    var cssProperty = "--".concat(cssVariableName);
+    return function() {
+        var doc = document.documentElement;
+        doc.style.setProperty(cssProperty, "".concat(window.innerHeight, "px"));
     };
 }
 /**
  * Adds window event listeners to populate the css variable `vh100`, or another input variable name, with the current window height.
- */
-function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
-    const refreshPropertyValue = refreshVh100Function(cssVariableName);
+ */ function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
+    var refreshPropertyValue = refreshVh100Function(cssVariableName);
     window.addEventListener('resize', refreshPropertyValue);
     window.addEventListener('orientationchange', refreshPropertyValue);
     refreshPropertyValue();
@@ -155,18 +411,50 @@ function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
 // MARK: Window Location Utiltiies
 /**
  * Whether or not the current host is localhost. Useful for determining local dev environments.
- */
-function isLocalhost() {
+ */ function isLocalhost() {
     return window.location.hostname === 'localhost';
 }
-function makeWindowPath(path) {
-    return `${getBaseWindowUrl()}${path}`;
+/**
+ * Constructs a full URL by combining the current window's base URL with the given relative path.
+ *
+ * @param path - Relative path to append to the base URL
+ * @returns Full URL string
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:3000
+ * const url = makeWindowPath('/api/users'); // "https://example.com:3000/api/users"
+ * ```
+ */ function makeWindowPath(path) {
+    return "".concat(getBaseWindowUrl()).concat(path);
 }
-function getBaseWindowUrl() {
-    const port = window.location.port ? ':' + window.location.port : '';
-    return `${window.location.protocol}//${window.location.hostname}${port}`;
+/**
+ * Returns the base URL of the current window, including protocol, hostname, and port (if present).
+ *
+ * @returns Base URL string without trailing slash
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:8080/some/path
+ * const base = getBaseWindowUrl(); // "https://example.com:8080"
+ * ```
+ */ function getBaseWindowUrl() {
+    var port = window.location.port ? ':' + window.location.port : '';
+    return "".concat(window.location.protocol, "//").concat(window.location.hostname).concat(port);
 }
-function getWindowPathNameWithQuery() {
+/**
+ * Returns the current window pathname concatenated with the query string.
+ *
+ * Useful for capturing the full relative URL for redirect-after-login or deep linking scenarios.
+ *
+ * @returns Pathname and query string (e.g. "/app/dashboard?tab=settings")
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com/app/dashboard?tab=settings
+ * const path = getWindowPathNameWithQuery(); // "/app/dashboard?tab=settings"
+ * ```
+ */ function getWindowPathNameWithQuery() {
     return window.location.pathname + window.location.search;
 }
 

package/index.esm.js

@@ -4,13 +4,11 @@ import { BehaviorSubject, shareReplay, switchMap, from, firstValueFrom } from 'r
 
 /**
  * Creatse a new BrowserObjectURLRef.
- */
-function browserObjectUrlRef() {
-    let browserUrl;
+ */ function browserObjectUrlRef() {
+    var browserUrl;
     /**
      * Revokes the existing browser object URL, if one exists.
-     */
-    function destroy() {
+     */ function destroy() {
         if (browserUrl) {
             URL.revokeObjectURL(browserUrl);
         }
@@ -23,128 +21,386 @@ function browserObjectUrlRef() {
         return browserUrl;
     }
     return {
-        destroy,
-        getBrowserUrl: () => browserUrl,
+        destroy: destroy,
+        getBrowserUrl: function getBrowserUrl() {
+            return browserUrl;
+        },
         createBrowserUrl: createBrowserUrl
     };
 }
 
-/*eslint @typescript-eslint/no-explicit-any:"off"*/
-// any is used with intent here. Proper typing with Window requires using the dynamic strings _windowKey and _callbackKey.
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * Used for loading services in the browser that are imported from other scripts, such as Facebook, Segment, Stripe, etc.
- */
-class AbstractAsyncWindowLoadedService {
-    _loading = new BehaviorSubject(undefined);
-    /**
+ */ var AbstractAsyncWindowLoadedService = /*#__PURE__*/ function() {
+    function AbstractAsyncWindowLoadedService(windowKey, callbackKey, serviceName, preload) {
+        var _this = this;
+        _class_call_check(this, AbstractAsyncWindowLoadedService);
+        _define_property(this, "_loading", new BehaviorSubject(undefined));
+        /**
      * Key that is attached to the window for the object that is the service when finished loading.
-     */
-    _windowKey;
-    /**
+     */ _define_property(this, "_windowKey", void 0);
+        /**
      * Optional key attached to window that is a function that is executed when the setup is complete.
-     */
-    _callbackKey;
-    /**
+     */ _define_property(this, "_callbackKey", void 0);
+        /**
      * Service name used in logging. Defaults to the windowKey.
-     */
-    _serviceName;
-    loading$ = this._loading.pipe(tapFirst(() => this.loadService()), filterMaybe(), shareReplay(1));
-    service$ = this.loading$.pipe(switchMap((x) => from(x)), shareReplay(1));
-    /**
-     * @param windowKey
-     * @param callbackKey
-     */
-    constructor(windowKey, callbackKey, serviceName, preload) {
+     */ _define_property(this, "_serviceName", void 0);
+        /**
+     * Observable that emits the loading promise. Subscribing triggers the initial load if not already started.
+     */ _define_property(this, "loading$", this._loading.pipe(tapFirst(function() {
+            return _this.loadService();
+        }), filterMaybe(), shareReplay(1)));
+        /**
+     * Observable that emits the resolved service instance once loading completes. Replays the last value to new subscribers.
+     */ _define_property(this, "service$", this.loading$.pipe(switchMap(function(x) {
+            return from(x);
+        }), shareReplay(1)));
         this._windowKey = windowKey;
         this._callbackKey = callbackKey;
-        this._serviceName = serviceName ?? windowKey;
+        this._serviceName = serviceName !== null && serviceName !== void 0 ? serviceName : windowKey;
         if (stringToBoolean(preload)) {
             // Begin loading the service immediately.
-            setTimeout(() => this.loadService().catch());
-        }
-    }
-    destroy() {
-        this._loading.complete();
-    }
-    getService() {
-        return firstValueFrom(this.service$);
-    }
-    // MARK: Loading
-    loadService() {
-        if (!this._loading.value) {
-            const loadingPromise = new Promise((resolve, reject) => {
-                let loadTry = 0;
-                const rejectWithError = () => {
-                    reject(new Error(`Service "${this._serviceName}" failed loading with windowKey "${this._windowKey}"`));
-                };
-                const tryLoad = () => {
-                    const windowRef = window;
-                    // Loaded before the promise.
-                    if (windowRef[this._windowKey]) {
-                        // Not yet finished loading async. Intercept the function.
-                        // console.log('Window key.');
-                        return resolve(this.completeLoadingService());
-                    }
-                    else if (this._callbackKey && windowRef[this._callbackKey]) {
-                        // console.log('Callback key.');
-                        windowRef[this._callbackKey] = () => resolve(this.completeLoadingService());
-                    }
-                    else if (loadTry < 10) {
-                        loadTry += 1;
-                        // console.log('Try reload...');
-                        setTimeout(() => tryLoad(), 1000);
-                    }
-                    else {
-                        const retry = this._onLoadServiceFailure();
-                        if (retry) {
-                            retry.then((x) => resolve(x)).catch(() => rejectWithError());
-                        }
-                        else {
-                            rejectWithError();
-                        }
-                    }
-                };
-                tryLoad();
+            setTimeout(function() {
+                return _this.loadService().catch();
             });
-            this._loading.next(loadingPromise);
         }
-        return this._loading.value;
     }
-    _onLoadServiceFailure() {
-        // override in parent if needed.
-    }
-    async completeLoadingService() {
-        await this._prepareCompleteLoadingService();
-        const service = window[this._windowKey];
-        if (!service) {
-            throw new Error(`Service "${this._serviceName}" could not complete loading.`);
+    _create_class(AbstractAsyncWindowLoadedService, [
+        {
+            /**
+     * Completes the internal loading subject, stopping any pending service resolution.
+     */ key: "destroy",
+            value: function destroy() {
+                this._loading.complete();
+            }
+        },
+        {
+            /**
+     * Returns a promise that resolves with the loaded service instance.
+     *
+     * Triggers loading if not already started.
+     */ key: "getService",
+            value: function getService() {
+                return firstValueFrom(this.service$);
+            }
+        },
+        {
+            // MARK: Loading
+            /**
+     * Initiates the service loading process by polling the `window` object for the service key.
+     *
+     * Retries up to 10 times at 1-second intervals before invoking `_onLoadServiceFailure()`.
+     * Subsequent calls return the same promise without re-initiating.
+     *
+     * @returns Promise that resolves with the loaded service
+     */ key: "loadService",
+            value: function loadService() {
+                var _this = this;
+                if (!this._loading.value) {
+                    var loadingPromise = new Promise(function(resolve, reject) {
+                        var loadTry = 0;
+                        var rejectWithError = function rejectWithError() {
+                            reject(new Error('Service "'.concat(_this._serviceName, '" failed loading with windowKey "').concat(_this._windowKey, '"')));
+                        };
+                        var tryLoad = function tryLoad1() {
+                            var windowRef = window;
+                            // Loaded before the promise.
+                            if (windowRef[_this._windowKey]) {
+                                // Not yet finished loading async. Intercept the function.
+                                // console.log('Window key.');
+                                return resolve(_this.completeLoadingService());
+                            } else if (_this._callbackKey && windowRef[_this._callbackKey]) {
+                                // console.log('Callback key.');
+                                windowRef[_this._callbackKey] = function() {
+                                    return resolve(_this.completeLoadingService());
+                                };
+                            } else if (loadTry < 10) {
+                                loadTry += 1;
+                                // console.log('Try reload...');
+                                setTimeout(function() {
+                                    return tryLoad();
+                                }, 1000);
+                            } else {
+                                var retry = _this._onLoadServiceFailure();
+                                if (retry) {
+                                    retry.then(function(x) {
+                                        return resolve(x);
+                                    }).catch(function() {
+                                        return rejectWithError();
+                                    });
+                                } else {
+                                    rejectWithError();
+                                }
+                            }
+                        };
+                        tryLoad();
+                    });
+                    this._loading.next(loadingPromise);
+                }
+                return this._loading.value;
+            }
+        },
+        {
+            /**
+     * Hook called when the service fails to load after all retry attempts.
+     *
+     * Subclasses can override to attempt an alternative loading strategy or return a fallback promise.
+     *
+     * @returns A promise resolving with the service if recovery succeeds, or `void` to reject
+     */ key: "_onLoadServiceFailure",
+            value: function _onLoadServiceFailure() {
+            // override in parent if needed.
+            }
+        },
+        {
+            key: "completeLoadingService",
+            value: function completeLoadingService() {
+                return _async_to_generator(function() {
+                    var service, initializedService;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this._prepareCompleteLoadingService()
+                                ];
+                            case 1:
+                                _state.sent();
+                                service = window[this._windowKey];
+                                if (!service) {
+                                    throw new Error('Service "'.concat(this._serviceName, '" could not complete loading.'));
+                                }
+                                return [
+                                    4,
+                                    this._initService(service)
+                                ];
+                            case 2:
+                                initializedService = _state.sent();
+                                return [
+                                    2,
+                                    initializedService !== null && initializedService !== void 0 ? initializedService : service
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            /**
+     * Hook called before completing the service load. Subclasses can override to perform
+     * additional async setup before the service reference is read from `window`.
+     */ key: "_prepareCompleteLoadingService",
+            value: function _prepareCompleteLoadingService() {
+                return Promise.resolve();
+            }
+        },
+        {
+            /**
+     * Hook called after the service is retrieved from `window` to perform initialization.
+     *
+     * Subclasses can override to configure or wrap the service before it is emitted to subscribers.
+     *
+     * @param service - The raw service instance from the window
+     * @returns The initialized service, or void to use the original
+     */ key: "_initService",
+            value: function _initService(service) {
+                return Promise.resolve(service);
+            }
         }
-        // Init the API
-        const initializedService = await this._initService(service);
-        return initializedService ?? service;
-    }
-    _prepareCompleteLoadingService() {
-        return Promise.resolve();
-    }
-    _initService(service) {
-        return Promise.resolve(service);
-    }
-}
+    ]);
+    return AbstractAsyncWindowLoadedService;
+} 
+();
 
 // https://dev.to/maciejtrzcinski/100vh-problem-with-ios-safari-3ge9
-const DEFAULT_VH100_VARIABLE_NAME = 'vh100';
-function refreshVh100Function(cssVariableName = DEFAULT_VH100_VARIABLE_NAME) {
-    const cssProperty = `--${cssVariableName}`;
-    return () => {
-        const doc = document.documentElement;
-        doc.style.setProperty(cssProperty, `${window.innerHeight}px`);
+/**
+ * Default CSS custom property name used to store the viewport height value.
+ */ var DEFAULT_VH100_VARIABLE_NAME = 'vh100';
+/**
+ * Creates a function that sets a CSS custom property on `document.documentElement` to the current `window.innerHeight` in pixels.
+ *
+ * This is a workaround for the iOS Safari 100vh bug where `100vh` includes the browser chrome,
+ * causing layout overflow. The returned function can be called to refresh the property value.
+ *
+ * @param cssVariableName - Name of the CSS custom property (without the `--` prefix)
+ * @returns A zero-argument function that updates the CSS property to the current inner height
+ *
+ * @example
+ * ```typescript
+ * const refresh = refreshVh100Function('vh100');
+ * refresh(); // sets --vh100 to e.g. "812px"
+ * ```
+ */ function refreshVh100Function() {
+    var cssVariableName = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_VH100_VARIABLE_NAME;
+    var cssProperty = "--".concat(cssVariableName);
+    return function() {
+        var doc = document.documentElement;
+        doc.style.setProperty(cssProperty, "".concat(window.innerHeight, "px"));
     };
 }
 /**
  * Adds window event listeners to populate the css variable `vh100`, or another input variable name, with the current window height.
- */
-function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
-    const refreshPropertyValue = refreshVh100Function(cssVariableName);
+ */ function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
+    var refreshPropertyValue = refreshVh100Function(cssVariableName);
     window.addEventListener('resize', refreshPropertyValue);
     window.addEventListener('orientationchange', refreshPropertyValue);
     refreshPropertyValue();
@@ -153,18 +409,50 @@ function watchWindowAndUpdateVh100StyleProperty(cssVariableName) {
 // MARK: Window Location Utiltiies
 /**
  * Whether or not the current host is localhost. Useful for determining local dev environments.
- */
-function isLocalhost() {
+ */ function isLocalhost() {
     return window.location.hostname === 'localhost';
 }
-function makeWindowPath(path) {
-    return `${getBaseWindowUrl()}${path}`;
+/**
+ * Constructs a full URL by combining the current window's base URL with the given relative path.
+ *
+ * @param path - Relative path to append to the base URL
+ * @returns Full URL string
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:3000
+ * const url = makeWindowPath('/api/users'); // "https://example.com:3000/api/users"
+ * ```
+ */ function makeWindowPath(path) {
+    return "".concat(getBaseWindowUrl()).concat(path);
 }
-function getBaseWindowUrl() {
-    const port = window.location.port ? ':' + window.location.port : '';
-    return `${window.location.protocol}//${window.location.hostname}${port}`;
+/**
+ * Returns the base URL of the current window, including protocol, hostname, and port (if present).
+ *
+ * @returns Base URL string without trailing slash
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:8080/some/path
+ * const base = getBaseWindowUrl(); // "https://example.com:8080"
+ * ```
+ */ function getBaseWindowUrl() {
+    var port = window.location.port ? ':' + window.location.port : '';
+    return "".concat(window.location.protocol, "//").concat(window.location.hostname).concat(port);
 }
-function getWindowPathNameWithQuery() {
+/**
+ * Returns the current window pathname concatenated with the query string.
+ *
+ * Useful for capturing the full relative URL for redirect-after-login or deep linking scenarios.
+ *
+ * @returns Pathname and query string (e.g. "/app/dashboard?tab=settings")
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com/app/dashboard?tab=settings
+ * const path = getWindowPathNameWithQuery(); // "/app/dashboard?tab=settings"
+ * ```
+ */ function getWindowPathNameWithQuery() {
     return window.location.pathname + window.location.search;
 }
 

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@dereekb/browser",
-  "version": "13.2.2",
+  "version": "13.3.1",
   "peerDependencies": {
-    "@dereekb/util": "13.2.2",
-    "@dereekb/rxjs": "13.2.2",
+    "@dereekb/util": "13.3.1",
+    "@dereekb/rxjs": "13.3.1",
     "rxjs": "^7.8.0"
   },
   "dependencies": {},

package/src/lib/service.d.ts

@@ -1,6 +1,12 @@
 import { type Maybe, type Destroyable } from '@dereekb/util';
 import { type Observable } from 'rxjs';
+/**
+ * Record type representing a service instance attached to the `window` object, keyed by a string identifier.
+ */
 export type ServiceInWindow<T> = Record<string, Maybe<T>>;
+/**
+ * Record type representing a callback function attached to the `window` object, called when a service finishes loading.
+ */
 export type ServiceCallbackInWindow = Record<string, () => void>;
 /**
  * Used for loading services in the browser that are imported from other scripts, such as Facebook, Segment, Stripe, etc.
@@ -19,18 +25,61 @@ export declare abstract class AbstractAsyncWindowLoadedService<T> implements Des
      * Service name used in logging. Defaults to the windowKey.
      */
     private readonly _serviceName;
+    /**
+     * Observable that emits the loading promise. Subscribing triggers the initial load if not already started.
+     */
     readonly loading$: Observable<Promise<T>>;
+    /**
+     * Observable that emits the resolved service instance once loading completes. Replays the last value to new subscribers.
+     */
     readonly service$: Observable<T>;
     /**
-     * @param windowKey
-     * @param callbackKey
+     * @param windowKey - Key on the `window` object where the loaded service is stored
+     * @param callbackKey - Optional key on `window` for a callback invoked when the service script finishes loading
+     * @param serviceName - Human-readable name for logging; defaults to `windowKey`
+     * @param preload - When truthy, begins loading the service immediately on construction
      */
     constructor(windowKey: string, callbackKey?: string, serviceName?: Maybe<string>, preload?: Maybe<boolean | string>);
+    /**
+     * Completes the internal loading subject, stopping any pending service resolution.
+     */
     destroy(): void;
+    /**
+     * Returns a promise that resolves with the loaded service instance.
+     *
+     * Triggers loading if not already started.
+     */
     getService(): Promise<T>;
+    /**
+     * Initiates the service loading process by polling the `window` object for the service key.
+     *
+     * Retries up to 10 times at 1-second intervals before invoking `_onLoadServiceFailure()`.
+     * Subsequent calls return the same promise without re-initiating.
+     *
+     * @returns Promise that resolves with the loaded service
+     */
     protected loadService(): Promise<T>;
+    /**
+     * Hook called when the service fails to load after all retry attempts.
+     *
+     * Subclasses can override to attempt an alternative loading strategy or return a fallback promise.
+     *
+     * @returns A promise resolving with the service if recovery succeeds, or `void` to reject
+     */
     protected _onLoadServiceFailure(): Promise<T> | void;
     private completeLoadingService;
+    /**
+     * Hook called before completing the service load. Subclasses can override to perform
+     * additional async setup before the service reference is read from `window`.
+     */
     protected _prepareCompleteLoadingService(): Promise<unknown>;
+    /**
+     * Hook called after the service is retrieved from `window` to perform initialization.
+     *
+     * Subclasses can override to configure or wrap the service before it is emitted to subscribers.
+     *
+     * @param service - The raw service instance from the window
+     * @returns The initialized service, or void to use the original
+     */
     protected _initService(service: T): Promise<T | void>;
 }

package/src/lib/vh100.d.ts

@@ -1,4 +1,22 @@
+/**
+ * Default CSS custom property name used to store the viewport height value.
+ */
 export declare const DEFAULT_VH100_VARIABLE_NAME = "vh100";
+/**
+ * Creates a function that sets a CSS custom property on `document.documentElement` to the current `window.innerHeight` in pixels.
+ *
+ * This is a workaround for the iOS Safari 100vh bug where `100vh` includes the browser chrome,
+ * causing layout overflow. The returned function can be called to refresh the property value.
+ *
+ * @param cssVariableName - Name of the CSS custom property (without the `--` prefix)
+ * @returns A zero-argument function that updates the CSS property to the current inner height
+ *
+ * @example
+ * ```typescript
+ * const refresh = refreshVh100Function('vh100');
+ * refresh(); // sets --vh100 to e.g. "812px"
+ * ```
+ */
 export declare function refreshVh100Function(cssVariableName?: string): () => void;
 /**
  * Adds window event listeners to populate the css variable `vh100`, or another input variable name, with the current window height.

package/src/lib/window.d.ts

@@ -2,6 +2,42 @@
  * Whether or not the current host is localhost. Useful for determining local dev environments.
  */
 export declare function isLocalhost(): boolean;
+/**
+ * Constructs a full URL by combining the current window's base URL with the given relative path.
+ *
+ * @param path - Relative path to append to the base URL
+ * @returns Full URL string
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:3000
+ * const url = makeWindowPath('/api/users'); // "https://example.com:3000/api/users"
+ * ```
+ */
 export declare function makeWindowPath(path: string): string;
+/**
+ * Returns the base URL of the current window, including protocol, hostname, and port (if present).
+ *
+ * @returns Base URL string without trailing slash
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com:8080/some/path
+ * const base = getBaseWindowUrl(); // "https://example.com:8080"
+ * ```
+ */
 export declare function getBaseWindowUrl(): string;
+/**
+ * Returns the current window pathname concatenated with the query string.
+ *
+ * Useful for capturing the full relative URL for redirect-after-login or deep linking scenarios.
+ *
+ * @returns Pathname and query string (e.g. "/app/dashboard?tab=settings")
+ *
+ * @example
+ * ```typescript
+ * // On https://example.com/app/dashboard?tab=settings
+ * const path = getWindowPathNameWithQuery(); // "/app/dashboard?tab=settings"
+ * ```
+ */
 export declare function getWindowPathNameWithQuery(): string;