@joewinke/jatui 0.1.31 → 0.2.0

package/dist/types/messaging.js

@@ -1,7 +1,7 @@
 // Messaging System Types
 // Generic types for messaging UI components — no framework or backend dependencies
 // ─── Emoji Data Constants ─────────────────────────────────────────────
-export const EMOJI_CATEGORIES = [
+export var EMOJI_CATEGORIES = [
     { id: 'search', name: 'Search', icon: '🔍', description: 'Search results' },
     {
         id: 'frequently_used',
@@ -59,7 +59,7 @@ export const EMOJI_CATEGORIES = [
         description: 'Organization custom emojis'
     }
 ];
-export const SKIN_TONES = [
+export var SKIN_TONES = [
     { id: 'default', name: 'Default', unicode: '', preview: '👋' },
     { id: 'light', name: 'Light', unicode: '🏻', preview: '👋🏻' },
     { id: 'medium-light', name: 'Medium Light', unicode: '🏼', preview: '👋🏼' },
@@ -68,7 +68,7 @@ export const SKIN_TONES = [
     { id: 'dark', name: 'Dark', unicode: '🏿', preview: '👋🏿' }
 ];
 // Default quick-reaction emojis (used when no user preferences available)
-export const DEFAULT_QUICK_REACTIONS = [
+export var DEFAULT_QUICK_REACTIONS = [
     {
         unicode: '👍',
         name: 'Thumbs Up',

package/dist/types/pipeline.js

@@ -1,11 +1,11 @@
 // ─── Core Stage/Column Types ───
 // ─── Defaults ───
-export const DEFAULT_DRAG_CONFIG = {
+export var DEFAULT_DRAG_CONFIG = {
     enabled: true,
     flipDurationMs: 200,
     dropTargetClass: 'outline-dashed outline-2 outline-base-content/20'
 };
-export const DEFAULT_PIPELINE_CONFIG = {
+export var DEFAULT_PIPELINE_CONFIG = {
     views: ['kanban'],
     defaultView: 'kanban',
     drag: DEFAULT_DRAG_CONFIG,

package/dist/utils/currency.js

@@ -5,10 +5,12 @@
  * Format a number as USD currency string.
  * Override locale/currency by passing options.
  */
-export function formatCurrency(amount, locale = 'en-US', currency = 'USD') {
+export function formatCurrency(amount, locale, currency) {
+    if (locale === void 0) { locale = 'en-US'; }
+    if (currency === void 0) { currency = 'USD'; }
     return new Intl.NumberFormat(locale, {
         style: 'currency',
-        currency,
+        currency: currency,
         minimumFractionDigits: 2,
         maximumFractionDigits: 2
     }).format(amount);

package/dist/utils/daisyuiColors.js

@@ -4,15 +4,15 @@
  * Reads --color-* custom properties at runtime so any custom DaisyUI theme
  * works correctly. SSR-safe: falls back to transparent/black when window is absent.
  */
-let colorCache = new Map();
-let themeObserver = null;
+var colorCache = new Map();
+var themeObserver = null;
 function resolveViaDOM(colorName) {
-    const el = document.documentElement;
-    const raw = getComputedStyle(el).getPropertyValue(`--color-${colorName}`).trim();
+    var el = document.documentElement;
+    var raw = getComputedStyle(el).getPropertyValue("--color-".concat(colorName)).trim();
     if (raw)
         return raw;
     // DaisyUI v4 used shortened oklch channel vars (e.g. --p); try that form
-    const shortMap = {
+    var shortMap = {
         primary: '--p',
         'primary-content': '--pc',
         secondary: '--s',
@@ -34,11 +34,11 @@ function resolveViaDOM(colorName) {
         error: '--er',
         'error-content': '--erc',
     };
-    const shortVar = shortMap[colorName];
+    var shortVar = shortMap[colorName];
     if (shortVar) {
-        const shortRaw = getComputedStyle(el).getPropertyValue(shortVar).trim();
+        var shortRaw = getComputedStyle(el).getPropertyValue(shortVar).trim();
         if (shortRaw)
-            return `oklch(${shortRaw})`;
+            return "oklch(".concat(shortRaw, ")");
     }
     return 'oklch(0.5 0 0)';
 }
@@ -52,23 +52,25 @@ export function getDaisyUIColor(colorName) {
     if (colorCache.has(colorName)) {
         return colorCache.get(colorName);
     }
-    const resolved = resolveViaDOM(colorName);
+    var resolved = resolveViaDOM(colorName);
     colorCache.set(colorName, resolved);
     return resolved;
 }
 /**
  * Create a lighter version of a color using color-mix (works with hex and oklch).
  */
-export function lightenColor(color, amount = 0.2) {
-    const pct = Math.round(amount * 100);
-    return `color-mix(in oklch, white ${pct}%, ${color})`;
+export function lightenColor(color, amount) {
+    if (amount === void 0) { amount = 0.2; }
+    var pct = Math.round(amount * 100);
+    return "color-mix(in oklch, white ".concat(pct, "%, ").concat(color, ")");
 }
 /**
  * Create a darker version of a color using color-mix.
  */
-export function darkenColor(color, amount = 0.2) {
-    const pct = Math.round(amount * 100);
-    return `color-mix(in oklch, black ${pct}%, ${color})`;
+export function darkenColor(color, amount) {
+    if (amount === void 0) { amount = 0.2; }
+    var pct = Math.round(amount * 100);
+    return "color-mix(in oklch, black ".concat(pct, "%, ").concat(color, ")");
 }
 /**
  * Setup theme change detection.
@@ -78,9 +80,9 @@ export function watchThemeChanges(onThemeChange) {
     if (themeObserver) {
         themeObserver.disconnect();
     }
-    themeObserver = new MutationObserver((mutations) => {
-        let themeChanged = false;
-        mutations.forEach((mutation) => {
+    themeObserver = new MutationObserver(function (mutations) {
+        var themeChanged = false;
+        mutations.forEach(function (mutation) {
             if (mutation.type === 'attributes' &&
                 (mutation.attributeName === 'data-theme' ||
                     mutation.attributeName === 'class')) {
@@ -98,7 +100,7 @@ export function watchThemeChanges(onThemeChange) {
         attributes: true,
         attributeFilter: ['data-theme', 'class'],
     });
-    return () => {
+    return function () {
         if (themeObserver) {
             themeObserver.disconnect();
             themeObserver = null;
@@ -112,25 +114,25 @@ export function watchThemeChanges(onThemeChange) {
 export function isDarkTheme() {
     if (typeof window === 'undefined')
         return false;
-    const baseContent = getDaisyUIColor('base-content');
-    const base100 = getDaisyUIColor('base-100');
+    var baseContent = getDaisyUIColor('base-content');
+    var base100 = getDaisyUIColor('base-100');
     return getLuminance(baseContent) > getLuminance(base100);
 }
 function getLuminance(color) {
     // Resolve via a temporary off-screen canvas pixel
-    const canvas = document.createElement('canvas');
+    var canvas = document.createElement('canvas');
     canvas.width = 1;
     canvas.height = 1;
-    const ctx = canvas.getContext('2d');
+    var ctx = canvas.getContext('2d');
     if (!ctx)
         return 0.5;
     try {
         ctx.fillStyle = color;
         ctx.fillRect(0, 0, 1, 1);
-        const [r, g, b] = ctx.getImageData(0, 0, 1, 1).data;
+        var _a = ctx.getImageData(0, 0, 1, 1).data, r = _a[0], g = _a[1], b = _a[2];
         return (r * 299 + g * 587 + b * 114) / (1000 * 255);
     }
-    catch {
+    catch (_b) {
         return 0.5;
     }
 }

package/dist/utils/dateFormatters.d.ts

@@ -67,3 +67,23 @@ export declare function taskAge(dateStr: string): {
     label: string;
     color: string;
 };
+export type PacingLevel = 'fresh' | 'aging' | 'stale';
+export interface PacingResult {
+    level: PacingLevel;
+    color: string;
+}
+/**
+ * Generic 3-state pacing color: green while fresh, amber once aging past
+ * `warnAtSeconds`, red once stale past `alertAtSeconds`. Unlike taskAge()
+ * above (a fixed day-scale gradient for task rows), this takes caller-supplied
+ * thresholds so it works at any timescale — a stalled agent turn ages in
+ * seconds, an unanswered review ages in minutes, a stale ticket ages in days.
+ *
+ * Use this for "how long has X been in state Y, should I be concerned yet"
+ * anywhere a viewer currently has to read a raw duration to judge urgency.
+ *
+ * Usage:
+ *   const pacing = pacingColor(elapsedSeconds, 30, 120)
+ *   // <span style="color: {pacing.color}">{elapsedSeconds}s</span>
+ */
+export declare function pacingColor(elapsedSeconds: number, warnAtSeconds: number, alertAtSeconds: number): PacingResult;

package/dist/utils/dateFormatters.js

@@ -30,8 +30,8 @@ export function parseTimestamp(timestamp) {
         return null;
     if (timestamp instanceof Date)
         return isNaN(timestamp.getTime()) ? null : timestamp;
-    const normalized = normalizeTimestamp(timestamp);
-    const date = new Date(normalized);
+    var normalized = normalizeTimestamp(timestamp);
+    var date = new Date(normalized);
     return isNaN(date.getTime()) ? null : date;
 }
 /**
@@ -41,30 +41,30 @@ export function parseTimestamp(timestamp) {
 export function formatRelativeTime(dateStr) {
     if (!dateStr)
         return '-';
-    const date = parseTimestamp(dateStr);
+    var date = parseTimestamp(dateStr);
     if (!date)
         return '-';
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffMins = Math.floor(diffMs / (1000 * 60));
-    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    const diffWeeks = Math.floor(diffDays / 7);
-    const diffMonths = Math.floor(diffDays / 30);
-    const diffYears = Math.floor(diffDays / 365);
+    var now = new Date();
+    var diffMs = now.getTime() - date.getTime();
+    var diffMins = Math.floor(diffMs / (1000 * 60));
+    var diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+    var diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    var diffWeeks = Math.floor(diffDays / 7);
+    var diffMonths = Math.floor(diffDays / 30);
+    var diffYears = Math.floor(diffDays / 365);
     if (diffMins < 1)
         return 'now';
     if (diffMins < 60)
-        return `${diffMins}m`;
+        return "".concat(diffMins, "m");
     if (diffHours < 24)
-        return `${diffHours}h`;
+        return "".concat(diffHours, "h");
     if (diffDays < 7)
-        return `${diffDays}d`;
+        return "".concat(diffDays, "d");
     if (diffWeeks < 4)
-        return `${diffWeeks}w`;
+        return "".concat(diffWeeks, "w");
     if (diffMonths < 12)
-        return `${diffMonths}mo`;
-    return `${diffYears}y`;
+        return "".concat(diffMonths, "mo");
+    return "".concat(diffYears, "y");
 }
 /**
  * Format full date and time for tooltips and detailed views.
@@ -72,7 +72,7 @@ export function formatRelativeTime(dateStr) {
 export function formatFullDate(dateStr) {
     if (!dateStr)
         return '';
-    const date = parseTimestamp(dateStr);
+    var date = parseTimestamp(dateStr);
     if (!date)
         return '';
     return date.toLocaleString('en-US', {
@@ -89,7 +89,7 @@ export function formatFullDate(dateStr) {
 export function formatShortDate(dateStr) {
     if (!dateStr)
         return '';
-    const date = parseTimestamp(dateStr);
+    var date = parseTimestamp(dateStr);
     if (!date)
         return '';
     return date.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
@@ -101,21 +101,21 @@ export function formatShortDate(dateStr) {
 export function formatLastActivity(timestamp) {
     if (!timestamp)
         return 'Never';
-    const date = parseTimestamp(timestamp);
+    var date = parseTimestamp(timestamp);
     if (!date)
         return 'Never';
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffMins = Math.floor(diffMs / 60000);
-    const diffHours = Math.floor(diffMs / 3600000);
-    const diffDays = Math.floor(diffMs / 86400000);
+    var now = new Date();
+    var diffMs = now.getTime() - date.getTime();
+    var diffMins = Math.floor(diffMs / 60000);
+    var diffHours = Math.floor(diffMs / 3600000);
+    var diffDays = Math.floor(diffMs / 86400000);
     if (diffMins < 1)
         return 'Just now';
     if (diffMins < 60)
-        return `${diffMins}m ago`;
+        return "".concat(diffMins, "m ago");
     if (diffHours < 24)
-        return `${diffHours}h ago`;
-    return `${diffDays}d ago`;
+        return "".concat(diffHours, "h ago");
+    return "".concat(diffDays, "d ago");
 }
 /**
  * Format date for display (simple locale string).
@@ -123,7 +123,7 @@ export function formatLastActivity(timestamp) {
 export function formatDate(dateString) {
     if (!dateString)
         return 'N/A';
-    const date = parseTimestamp(dateString);
+    var date = parseTimestamp(dateString);
     if (!date)
         return 'N/A';
     return date.toLocaleString();
@@ -134,7 +134,7 @@ export function formatDate(dateString) {
 export function getTimeSinceMs(timestamp) {
     if (!timestamp)
         return Infinity;
-    const date = parseTimestamp(timestamp);
+    var date = parseTimestamp(timestamp);
     if (!date)
         return Infinity;
     return Date.now() - date.getTime();
@@ -158,7 +158,7 @@ export function isWithinMinutes(timestamp, minutes) {
 export function formatDateTime(dateStr) {
     if (!dateStr)
         return '';
-    const date = parseTimestamp(dateStr);
+    var date = parseTimestamp(dateStr);
     if (!date)
         return '';
     return date.toLocaleString(undefined, {
@@ -178,22 +178,43 @@ export function formatDateTime(dateStr) {
  *   // <span style="color: {age.color}">{age.label}</span>
  */
 export function taskAge(dateStr) {
-    const now = Date.now();
-    const created = new Date(dateStr).getTime();
-    const minutes = Math.floor((now - created) / 60000);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    const weeks = Math.floor(days / 7);
-    const months = Math.floor(days / 30);
+    var now = Date.now();
+    var created = new Date(dateStr).getTime();
+    var minutes = Math.floor((now - created) / 60000);
+    var hours = Math.floor(minutes / 60);
+    var days = Math.floor(hours / 24);
+    var weeks = Math.floor(days / 7);
+    var months = Math.floor(days / 30);
     if (minutes < 60)
-        return { label: `${minutes}m`, color: 'oklch(0.75 0.18 145)' }; // green — fresh
+        return { label: "".concat(minutes, "m"), color: 'oklch(0.75 0.18 145)' }; // green — fresh
     if (hours < 24)
-        return { label: `${hours}h`, color: 'oklch(0.75 0.18 145)' }; // green
+        return { label: "".concat(hours, "h"), color: 'oklch(0.75 0.18 145)' }; // green
     if (days < 3)
-        return { label: `${days}d`, color: 'oklch(0.70 0.15 200)' }; // blue — recent
+        return { label: "".concat(days, "d"), color: 'oklch(0.70 0.15 200)' }; // blue — recent
     if (days < 7)
-        return { label: `${days}d`, color: 'oklch(0.75 0.15 85)' }; // amber — aging
+        return { label: "".concat(days, "d"), color: 'oklch(0.75 0.15 85)' }; // amber — aging
     if (weeks < 4)
-        return { label: `${weeks}w`, color: 'oklch(0.65 0.18 50)' }; // orange — stale
-    return { label: `${months}mo`, color: 'oklch(0.65 0.20 25)' }; // red — old
+        return { label: "".concat(weeks, "w"), color: 'oklch(0.65 0.18 50)' }; // orange — stale
+    return { label: "".concat(months, "mo"), color: 'oklch(0.65 0.20 25)' }; // red — old
+}
+/**
+ * Generic 3-state pacing color: green while fresh, amber once aging past
+ * `warnAtSeconds`, red once stale past `alertAtSeconds`. Unlike taskAge()
+ * above (a fixed day-scale gradient for task rows), this takes caller-supplied
+ * thresholds so it works at any timescale — a stalled agent turn ages in
+ * seconds, an unanswered review ages in minutes, a stale ticket ages in days.
+ *
+ * Use this for "how long has X been in state Y, should I be concerned yet"
+ * anywhere a viewer currently has to read a raw duration to judge urgency.
+ *
+ * Usage:
+ *   const pacing = pacingColor(elapsedSeconds, 30, 120)
+ *   // <span style="color: {pacing.color}">{elapsedSeconds}s</span>
+ */
+export function pacingColor(elapsedSeconds, warnAtSeconds, alertAtSeconds) {
+    if (elapsedSeconds >= alertAtSeconds)
+        return { level: 'stale', color: 'oklch(0.65 0.20 25)' }; // red
+    if (elapsedSeconds >= warnAtSeconds)
+        return { level: 'aging', color: 'oklch(0.75 0.15 85)' }; // amber
+    return { level: 'fresh', color: 'oklch(0.75 0.18 145)' }; // green
 }

package/dist/utils/googleMapsLoader.js

@@ -8,60 +8,114 @@
  *   await loadGoogleMapsAPI({ apiKey: 'YOUR_KEY', libraries: ['marker', 'geometry'] })
  *   if (isGoogleMapsLoaded()) { ... }
  */
-let loadPromise = null;
-let isLoaded = false;
-export async function loadGoogleMapsAPI(options) {
-    if (typeof window === 'undefined')
-        return;
-    const { apiKey, libraries = [] } = options;
-    if (!apiKey) {
-        console.warn('googleMapsLoader: No API key provided');
-        return;
-    }
-    // If already loaded and all required libraries are available, return
-    if (isLoaded && window.google?.maps) {
-        const allLibrariesAvailable = libraries.every((lib) => {
-            switch (lib) {
-                case 'places':
-                    return window.google?.maps?.places;
-                case 'geometry':
-                    return window.google?.maps?.geometry;
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { 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:
-                    return true;
+                    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;
             }
-        });
-        if (allLibrariesAvailable)
-            return;
+            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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
     }
-    // If already loading, return the existing promise
-    if (loadPromise)
-        return loadPromise;
-    // Combine default libraries with requested ones
-    const allLibraries = Array.from(new Set(['geometry', 'places', 'marker', ...libraries]));
-    loadPromise = new Promise((resolve, reject) => {
-        const script = document.createElement('script');
-        script.src = `https://maps.googleapis.com/maps/api/js?key=${apiKey}&libraries=${allLibraries.join(',')}`;
-        script.async = true;
-        script.defer = true;
-        script.onload = () => {
-            isLoaded = true;
-            loadPromise = null;
-            resolve();
-        };
-        script.onerror = (error) => {
-            loadPromise = null;
-            reject(error);
-        };
-        document.head.appendChild(script);
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var loadPromise = null;
+var isLoaded = false;
+export function loadGoogleMapsAPI(options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var apiKey, _a, libraries, allLibrariesAvailable, allLibraries;
+        var _b;
+        return __generator(this, function (_c) {
+            if (typeof window === 'undefined')
+                return [2 /*return*/];
+            apiKey = options.apiKey, _a = options.libraries, libraries = _a === void 0 ? [] : _a;
+            if (!apiKey) {
+                console.warn('googleMapsLoader: No API key provided');
+                return [2 /*return*/];
+            }
+            // If already loaded and all required libraries are available, return
+            if (isLoaded && ((_b = window.google) === null || _b === void 0 ? void 0 : _b.maps)) {
+                allLibrariesAvailable = libraries.every(function (lib) {
+                    var _a, _b, _c, _d;
+                    switch (lib) {
+                        case 'places':
+                            return (_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.places;
+                        case 'geometry':
+                            return (_d = (_c = window.google) === null || _c === void 0 ? void 0 : _c.maps) === null || _d === void 0 ? void 0 : _d.geometry;
+                        default:
+                            return true;
+                    }
+                });
+                if (allLibrariesAvailable)
+                    return [2 /*return*/];
+            }
+            // If already loading, return the existing promise
+            if (loadPromise)
+                return [2 /*return*/, loadPromise];
+            allLibraries = Array.from(new Set(__spreadArray(['geometry', 'places', 'marker'], libraries, true)));
+            loadPromise = new Promise(function (resolve, reject) {
+                var script = document.createElement('script');
+                script.src = "https://maps.googleapis.com/maps/api/js?key=".concat(apiKey, "&libraries=").concat(allLibraries.join(','));
+                script.async = true;
+                script.defer = true;
+                script.onload = function () {
+                    isLoaded = true;
+                    loadPromise = null;
+                    resolve();
+                };
+                script.onerror = function (error) {
+                    loadPromise = null;
+                    reject(error);
+                };
+                document.head.appendChild(script);
+            });
+            return [2 /*return*/, loadPromise];
+        });
     });
-    return loadPromise;
 }
 export function isGoogleMapsLoaded() {
-    return isLoaded && !!window.google?.maps;
+    var _a;
+    return isLoaded && !!((_a = window.google) === null || _a === void 0 ? void 0 : _a.maps);
 }
 export function isPlacesLoaded() {
-    return isGoogleMapsLoaded() && !!window.google?.maps?.places;
+    var _a, _b;
+    return isGoogleMapsLoaded() && !!((_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.places);
 }
 export function isGeometryLoaded() {
-    return isGoogleMapsLoaded() && !!window.google?.maps?.geometry;
+    var _a, _b;
+    return isGoogleMapsLoaded() && !!((_b = (_a = window.google) === null || _a === void 0 ? void 0 : _a.maps) === null || _b === void 0 ? void 0 : _b.geometry);
 }