@screenly/edge-apps 0.0.1 → 0.0.2

package/dist/utils/error-handling.js

@@ -0,0 +1,16 @@
+import panic from 'panic-overlay';
+import { getSettingWithDefault, signalReady } from './settings.js';
+/**
+ * Set up error handling with panic-overlay
+ * Configures panic-overlay to display errors on screen if the display_errors setting is enabled
+ */
+export function setupErrorHandling() {
+    const displayErrors = getSettingWithDefault('display_errors', false);
+    panic.configure({
+        handleErrors: displayErrors,
+    });
+    if (displayErrors) {
+        window.addEventListener('error', signalReady);
+        window.addEventListener('unhandledrejection', signalReady);
+    }
+}

package/dist/utils/html.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Escapes HTML special characters to prevent XSS attacks
+ * @param text - The text to escape
+ * @returns The escaped text safe for insertion into HTML
+ */
+export declare function escapeHtml(text: string): string;
+//# sourceMappingURL=html.d.ts.map

package/dist/utils/html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../src/utils/html.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAO/C"}

package/dist/utils/html.js

@@ -0,0 +1,13 @@
+/**
+ * Escapes HTML special characters to prevent XSS attacks
+ * @param text - The text to escape
+ * @returns The escaped text safe for insertion into HTML
+ */
+export function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './calendar.js';
+export * from './error-handling.js';
+export * from './html.js';
+export * from './theme.js';
+export * from './locale.js';
+export * from './metadata.js';
+export * from './oauth.js';
+export * from './settings.js';
+export * from './screen.js';
+export * from './weather.js';
+export * from './utm.js';
+export * from './template.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA;AAC7B,cAAc,qBAAqB,CAAA;AACnC,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,YAAY,CAAA;AAC1B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA;AAC5B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA"}

package/dist/utils/index.js

@@ -0,0 +1,12 @@
+export * from './calendar.js';
+export * from './error-handling.js';
+export * from './html.js';
+export * from './theme.js';
+export * from './locale.js';
+export * from './metadata.js';
+export * from './oauth.js';
+export * from './settings.js';
+export * from './screen.js';
+export * from './weather.js';
+export * from './utm.js';
+export * from './template.js';

package/dist/utils/locale.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Resolve timezone configuration with fallback chain
+ * Fallback order: override setting (validated) → GPS-based detection → 'UTC'
+ */
+export declare function getTimeZone(): Promise<string>;
+/**
+ * Resolve locale configuration with fallback chain
+ * Fallback order: override setting (validated) → GPS-based detection → browser locale → 'en'
+ */
+export declare function getLocale(): Promise<string>;
+/**
+ * Format coordinates into a human-readable string
+ * Example: "37.3861° N, 122.0839° W"
+ */
+export declare function formatCoordinates(coordinates: [number, number]): string;
+/**
+ * Format a date in a locale-aware way.
+ *
+ * Examples:
+ * - "December 25, 2023" in en-US
+ * - "25 December 2023" in en-GB
+ * - "2023年12月25日" in ja-JP
+ * - "25.12.2023" in de-DE
+ *
+ * By default, formats as a full date (year, month, day). Callers can
+ * override or extend the formatting via the `options` parameter.
+ */
+export declare function formatLocalizedDate(date: Date, locale: string, options?: Intl.DateTimeFormatOptions): string;
+/**
+ * Get localized day names (Sunday-Saturday)
+ * Returns both full and short forms
+ */
+export declare function getLocalizedDayNames(locale: string): {
+    full: string[];
+    short: string[];
+};
+/**
+ * Get localized month names (January-December)
+ * Returns both full and short forms
+ */
+export declare function getLocalizedMonthNames(locale: string): {
+    full: string[];
+    short: string[];
+};
+/**
+ * Detect if a locale uses 12-hour or 24-hour format
+ */
+export declare function detectHourFormat(locale: string): 'hour12' | 'hour24';
+/**
+ * Determine measurement unit based on country code
+ * @param countryCode - Two-character ISO country code (e.g., 'US', 'GB')
+ * @returns 'imperial' for Fahrenheit countries, 'metric' for all others
+ */
+export declare function getMeasurementUnitByCountry(countryCode: string): 'metric' | 'imperial';
+/**
+ * Format time with locale and timezone awareness
+ * Returns structured time parts for flexible composition
+ */
+export declare function formatTime(date: Date, locale: string, timezone: string, options?: {
+    hour12?: boolean;
+}): {
+    hour: string;
+    minute: string;
+    second: string;
+    dayPeriod?: string;
+    formatted: string;
+};
+//# sourceMappingURL=locale.d.ts.map

package/dist/utils/locale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/utils/locale.ts"],"names":[],"mappings":"AAgEA;;;GAGG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAuBnD;AAED;;;GAGG;AACH,wBAAsB,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAmCjD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CASvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,IAAI,CAAC,qBAAqB,GACnC,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IACpD,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAuBA;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG;IACtD,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAgBA;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAWpE;AAqED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,GAClB,QAAQ,GAAG,UAAU,CAIvB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB,GACA;IACD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;CAClB,CA4CA"}

package/dist/utils/locale.js

@@ -0,0 +1,318 @@
+import tzlookup from '@photostructure/tz-lookup';
+import clm from 'country-locale-map';
+import { getSettingWithDefault } from './settings.js';
+import { getMetadata } from './metadata.js';
+/**
+ * Validate timezone using native Intl API
+ */
+function isValidTimezone(timezone) {
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: timezone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate locale using native Intl API
+ * Ensures the resolved locale's language code matches the requested locale
+ */
+function isValidLocale(locale) {
+    // Basic format validation: should be at least 2 characters
+    // and not end with a hyphen
+    if (!locale || locale.length < 2 || locale.endsWith('-')) {
+        return false;
+    }
+    // Language code should be 2-3 characters, followed by optional region/script
+    const localeRegex = /^[a-z]{2,3}(-[a-z]{2,})*$/i;
+    if (!localeRegex.test(locale)) {
+        return false;
+    }
+    try {
+        const formatter = new Intl.DateTimeFormat(locale);
+        const resolved = formatter.resolvedOptions().locale;
+        // Check if the resolved locale's language code matches the requested one
+        // e.g., 'zh-CN' → language 'zh', 'en-US' → language 'en'
+        const requestedLanguage = locale.toLowerCase().split('-')[0];
+        const resolvedLanguage = resolved.toLowerCase().split('-')[0];
+        if (requestedLanguage !== resolvedLanguage) {
+            return false;
+        }
+        // If request includes a region/script, verify it's preserved in resolution
+        // This catches cases like 'en-INVALID' resolving to 'en'
+        const requestedParts = locale.toLowerCase().split('-');
+        if (requestedParts.length > 1) {
+            const resolvedParts = resolved.toLowerCase().split('-');
+            // If we requested more than just language, the resolved should have similar depth
+            // (or not drop the requested parts entirely)
+            if (resolvedParts.length < requestedParts.length) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve timezone configuration with fallback chain
+ * Fallback order: override setting (validated) → GPS-based detection → 'UTC'
+ */
+export async function getTimeZone() {
+    // Priority 1: Use override setting if provided and valid
+    const overrideTimezone = getSettingWithDefault('override_timezone', '');
+    if (overrideTimezone) {
+        // Validate using native Intl API
+        if (isValidTimezone(overrideTimezone)) {
+            return overrideTimezone;
+        }
+        console.warn(`Invalid timezone override: "${overrideTimezone}", falling back to GPS detection`);
+    }
+    try {
+        const [latitude, longitude] = getMetadata().coordinates;
+        return tzlookup(latitude, longitude);
+    }
+    catch (error) {
+        console.warn('Failed to get timezone from coordinates, using UTC:', error);
+        return 'UTC';
+    }
+}
+/**
+ * Resolve locale configuration with fallback chain
+ * Fallback order: override setting (validated) → GPS-based detection → browser locale → 'en'
+ */
+export async function getLocale() {
+    // Priority 1: Use override setting if provided and valid
+    const overrideLocale = getSettingWithDefault('override_locale', '');
+    if (overrideLocale) {
+        const normalizedLocale = overrideLocale.replaceAll('_', '-');
+        // Validate the override locale
+        if (isValidLocale(normalizedLocale)) {
+            return normalizedLocale;
+        }
+        console.warn(`Invalid locale override: "${overrideLocale}", falling back to GPS detection`);
+    }
+    const [lat, lng] = getMetadata().coordinates;
+    const defaultLocale = (navigator?.languages?.length
+        ? navigator.languages[0]
+        : navigator.language) || 'en';
+    try {
+        // Lazy-load offline-geocode-city so apps that never call getLocale
+        // don't need to bundle it (and won't hit its lz-string dependency).
+        const { getNearestCity } = await import('offline-geocode-city');
+        const data = await getNearestCity(lat, lng);
+        const countryCode = data.countryIso2.toUpperCase();
+        const locale = clm.getLocaleByAlpha2(countryCode) || defaultLocale;
+        return locale.replace('_', '-');
+    }
+    catch (error) {
+        console.warn('Failed to get locale from coordinates, using default:', error);
+        return defaultLocale;
+    }
+}
+/**
+ * Format coordinates into a human-readable string
+ * Example: "37.3861° N, 122.0839° W"
+ */
+export function formatCoordinates(coordinates) {
+    const [latitude, longitude] = coordinates;
+    const latString = `${Math.abs(latitude).toFixed(4)}\u00B0`;
+    const latDirection = latitude > 0 ? 'N' : 'S';
+    const lngString = `${Math.abs(longitude).toFixed(4)}\u00B0`;
+    const lngDirection = longitude > 0 ? 'E' : 'W';
+    return `${latString} ${latDirection}, ${lngString} ${lngDirection}`;
+}
+/**
+ * Format a date in a locale-aware way.
+ *
+ * Examples:
+ * - "December 25, 2023" in en-US
+ * - "25 December 2023" in en-GB
+ * - "2023年12月25日" in ja-JP
+ * - "25.12.2023" in de-DE
+ *
+ * By default, formats as a full date (year, month, day). Callers can
+ * override or extend the formatting via the `options` parameter.
+ */
+export function formatLocalizedDate(date, locale, options) {
+    const baseOptions = {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+    };
+    try {
+        const formatter = new Intl.DateTimeFormat(locale, {
+            ...baseOptions,
+            ...options,
+        });
+        return formatter.format(date);
+    }
+    catch {
+        // Fallback to a safe default for unrecognized locales
+        const fallbackFormatter = new Intl.DateTimeFormat('en-US', {
+            ...baseOptions,
+            ...options,
+        });
+        return fallbackFormatter.format(date);
+    }
+}
+/**
+ * Get localized day names (Sunday-Saturday)
+ * Returns both full and short forms
+ */
+export function getLocalizedDayNames(locale) {
+    const full = [];
+    const short = [];
+    // Find the first Sunday of the current year using local time
+    // (avoid Date.UTC — toLocaleDateString uses local time, so UTC midnight
+    //  maps to the previous day in negative-offset timezones like PST)
+    const now = new Date();
+    const year = now.getFullYear();
+    const firstDay = new Date(year, 0, 1);
+    const dayOfWeek = firstDay.getDay(); // 0 = Sunday, 1 = Monday, etc.
+    // Calculate offset to get to the first Sunday
+    const offset = dayOfWeek === 0 ? 0 : 7 - dayOfWeek;
+    for (let i = 0; i < 7; i++) {
+        const date = new Date(year, 0, 1 + offset + i);
+        full.push(date.toLocaleDateString(locale, { weekday: 'long' }));
+        short.push(date.toLocaleDateString(locale, { weekday: 'short' }));
+    }
+    return { full, short };
+}
+/**
+ * Get localized month names (January-December)
+ * Returns both full and short forms
+ */
+export function getLocalizedMonthNames(locale) {
+    const full = [];
+    const short = [];
+    // Iterate through each month of the current year
+    const now = new Date();
+    const year = now.getFullYear();
+    for (let i = 0; i < 12; i++) {
+        const date = new Date(year, i, 1);
+        full.push(date.toLocaleDateString(locale, { month: 'long' }));
+        short.push(date.toLocaleDateString(locale, { month: 'short' }));
+    }
+    return { full, short };
+}
+/**
+ * Detect if a locale uses 12-hour or 24-hour format
+ */
+export function detectHourFormat(locale) {
+    try {
+        const formatter = new Intl.DateTimeFormat(locale, {
+            hour: 'numeric',
+        });
+        return formatter.resolvedOptions().hour12 ? 'hour12' : 'hour24';
+    }
+    catch {
+        // Fallback to 24-hour for unrecognized locales
+        return 'hour24';
+    }
+}
+/**
+ * Extract time parts from a DateTimeFormat formatter
+ */
+function extractTimePartsFromFormatter(date, formatter) {
+    const parts = formatter.formatToParts(date);
+    const partMap = {};
+    parts.forEach((part) => {
+        if (part.type !== 'literal') {
+            partMap[part.type] = part.value;
+        }
+    });
+    return {
+        hour: partMap.hour || '00',
+        minute: partMap.minute || '00',
+        second: partMap.second || '00',
+        dayPeriod: partMap.dayPeriod,
+    };
+}
+/**
+ * Get locale extension for numeral system based on language
+ * This enables locale-specific number representations (e.g., Thai numerals, Chinese numerals)
+ * Uses Intl.Locale API to robustly handle existing extensions
+ */
+function getLocaleWithNumeralSystem(locale) {
+    const language = locale.toLowerCase().split('-')[0];
+    // Map of languages to their numeral system extensions
+    const numeralSystemMap = {
+        th: 'thai', // Thai numerals: ๐๑๒๓๔๕๖๗๘๙
+        zh: 'hanidec', // Chinese numerals: 〇一二三四五六七八九
+    };
+    const numeralSystem = numeralSystemMap[language];
+    if (!numeralSystem) {
+        return locale;
+    }
+    try {
+        // Use Intl.Locale API to robustly handle existing extensions
+        // This properly merges extensions instead of creating duplicates
+        const localeObj = new Intl.Locale(locale, {
+            numberingSystem: numeralSystem,
+        });
+        return localeObj.toString();
+    }
+    catch (error) {
+        // Fallback to original locale if Intl.Locale fails
+        console.warn(`Failed to apply numeral system to locale "${locale}":`, error);
+        return locale;
+    }
+}
+// Countries that use Fahrenheit scale
+// United States, Bahamas, Cayman Islands, Liberia, Palau,
+// Federated States of Micronesia, Marshall Islands
+const FAHRENHEIT_COUNTRIES = ['US', 'BS', 'KY', 'LR', 'PW', 'FM', 'MH'];
+/**
+ * Determine measurement unit based on country code
+ * @param countryCode - Two-character ISO country code (e.g., 'US', 'GB')
+ * @returns 'imperial' for Fahrenheit countries, 'metric' for all others
+ */
+export function getMeasurementUnitByCountry(countryCode) {
+    return FAHRENHEIT_COUNTRIES.includes(countryCode.toUpperCase())
+        ? 'imperial'
+        : 'metric';
+}
+/**
+ * Format time with locale and timezone awareness
+ * Returns structured time parts for flexible composition
+ */
+export function formatTime(date, locale, timezone, options) {
+    try {
+        // Determine hour format if not explicitly provided
+        const hour12 = options?.hour12 ?? detectHourFormat(locale) === 'hour12';
+        // Get locale with numeral system extension if applicable
+        const localeWithNumerals = getLocaleWithNumeralSystem(locale);
+        // Format with Intl API for proper localization
+        const formatter = new Intl.DateTimeFormat(localeWithNumerals, {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12,
+            timeZone: timezone,
+        });
+        const timeParts = extractTimePartsFromFormatter(date, formatter);
+        return {
+            ...timeParts,
+            formatted: formatter.format(date),
+        };
+    }
+    catch (error) {
+        console.warn(`Failed to format time for locale "${locale}" and timezone "${timezone}":`, error);
+        // Fallback to UTC in English
+        const fallbackFormatter = new Intl.DateTimeFormat('en', {
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+            timeZone: 'UTC',
+        });
+        const timeParts = extractTimePartsFromFormatter(date, fallbackFormatter);
+        return {
+            ...timeParts,
+            formatted: fallbackFormatter.format(date),
+        };
+    }
+}

package/dist/utils/metadata.d.ts

@@ -0,0 +1,39 @@
+import type { ScreenlyMetadata } from '../types/index.js';
+import { Hardware } from '../types/index.js';
+/**
+ * Get the Screenly metadata
+ */
+export declare function getMetadata(): ScreenlyMetadata;
+/**
+ * Get formatted coordinates from metadata
+ */
+export declare function getFormattedCoordinates(): string;
+/**
+ * Get the screen name
+ */
+export declare function getScreenName(): string;
+/**
+ * Get the hostname
+ */
+export declare function getHostname(): string;
+/**
+ * Get the location
+ */
+export declare function getLocation(): string;
+/**
+ * Get the hardware type
+ */
+export declare function getHardware(): Hardware;
+/**
+ * Get the Screenly version
+ */
+export declare function getScreenlyVersion(): string;
+/**
+ * Get the tags
+ */
+export declare function getTags(): string[];
+/**
+ * Check if a specific tag exists
+ */
+export declare function hasTag(tag: string): boolean;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/utils/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/utils/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAA;AACzD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAG5C;;GAEG;AACH,wBAAgB,WAAW,IAAI,gBAAgB,CAE9C;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,CAEtC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,MAAM,CAEpC;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAgBtC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,OAAO,IAAI,MAAM,EAAE,CAElC;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3C"}

package/dist/utils/metadata.js

@@ -0,0 +1,66 @@
+import { Hardware } from '../types/index.js';
+import { formatCoordinates } from './locale.js';
+/**
+ * Get the Screenly metadata
+ */
+export function getMetadata() {
+    return screenly.metadata;
+}
+/**
+ * Get formatted coordinates from metadata
+ */
+export function getFormattedCoordinates() {
+    return formatCoordinates(screenly.metadata.coordinates);
+}
+/**
+ * Get the screen name
+ */
+export function getScreenName() {
+    return screenly.metadata.screen_name;
+}
+/**
+ * Get the hostname
+ */
+export function getHostname() {
+    return screenly.metadata.hostname;
+}
+/**
+ * Get the location
+ */
+export function getLocation() {
+    return screenly.metadata.location;
+}
+/**
+ * Get the hardware type
+ */
+export function getHardware() {
+    const hardware = screenly.metadata.hardware;
+    if (hardware === undefined) {
+        return Hardware.Anywhere;
+    }
+    if (hardware === 'Raspberry Pi') {
+        return Hardware.RaspberryPi;
+    }
+    if (hardware === 'Screenly Player Max') {
+        return Hardware.ScreenlyPlayerMax;
+    }
+    return Hardware.Unknown;
+}
+/**
+ * Get the Screenly version
+ */
+export function getScreenlyVersion() {
+    return screenly.metadata.screenly_version;
+}
+/**
+ * Get the tags
+ */
+export function getTags() {
+    return screenly.metadata.tags;
+}
+/**
+ * Check if a specific tag exists
+ */
+export function hasTag(tag) {
+    return screenly.metadata.tags.includes(tag);
+}

package/dist/utils/oauth.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Starts a background loop that calls `onRefresh` every 30 minutes, with
+ * exponential back-off on failure (up to ~128 minutes between retries).
+ * Stops retrying after 7 consecutive failures.
+ */
+export declare const initTokenRefreshLoop: (onRefresh: () => Promise<void>) => void;
+/**
+ * Retrieves credentials from the Screenly OAuth service
+ * @param tokenType The token endpoint type (default: 'access_token')
+ * @returns An object containing the token and optional metadata from the OAuth provider
+ */
+export declare const getCredentials: (tokenType?: string) => Promise<{
+    token: string;
+    metadata?: Record<string, unknown>;
+}>;
+//# sourceMappingURL=oauth.d.ts.map

package/dist/utils/oauth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../src/utils/oauth.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,MAAM,OAAO,CAAC,IAAI,CAAC,KAAG,IAsBrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,YAAW,MAAuB,KACjC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAAE,CAc/D,CAAA"}

package/dist/utils/oauth.js

@@ -0,0 +1,42 @@
+const TOKEN_REFRESH_INTERVAL_SEC = 30 * 60;
+/**
+ * Starts a background loop that calls `onRefresh` every 30 minutes, with
+ * exponential back-off on failure (up to ~128 minutes between retries).
+ * Stops retrying after 7 consecutive failures.
+ */
+export const initTokenRefreshLoop = (onRefresh) => {
+    let errorStep = 0;
+    const initErrorDelaySec = 15;
+    const maxErrorStep = 7;
+    const run = async () => {
+        let nextTimeout = TOKEN_REFRESH_INTERVAL_SEC;
+        try {
+            await onRefresh();
+            errorStep = 0;
+        }
+        catch {
+            nextTimeout = Math.min(initErrorDelaySec * Math.pow(2, errorStep), nextTimeout);
+            if (errorStep >= maxErrorStep)
+                return;
+            errorStep++;
+        }
+        setTimeout(run, nextTimeout * 1000);
+    };
+    setTimeout(run, TOKEN_REFRESH_INTERVAL_SEC * 1000);
+};
+/**
+ * Retrieves credentials from the Screenly OAuth service
+ * @param tokenType The token endpoint type (default: 'access_token')
+ * @returns An object containing the token and optional metadata from the OAuth provider
+ */
+export const getCredentials = async (tokenType = 'access_token') => {
+    const response = await fetch(screenly.settings.screenly_oauth_tokens_url + tokenType + '/', {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${screenly.settings.screenly_app_auth_token}`,
+        },
+    });
+    const { token, metadata } = await response.json();
+    return { token, metadata };
+};

package/dist/utils/screen.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Screen Utilities
+ * Utilities for screen orientation, dimensions, and other screen-related functions
+ */
+/**
+ * Check if the current screen orientation is portrait
+ * @returns true if portrait, false if landscape
+ */
+export declare function isPortrait(): boolean;
+/**
+ * Check if the current screen orientation is landscape
+ * @returns true if landscape, false if portrait
+ */
+export declare function isLandscape(): boolean;
+/**
+ * Get the current screen orientation
+ * @returns 'portrait' | 'landscape'
+ */
+export declare function getOrientation(): 'portrait' | 'landscape';
+/**
+ * Center the auto-scaler element vertically within the viewport.
+ * Useful for apps that restrict display to a single orientation (portrait or
+ * landscape), where the auto-scaler may not fill the full viewport height.
+ */
+export declare function centerAutoScalerVertically(): void;
+//# sourceMappingURL=screen.d.ts.map

package/dist/utils/screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../src/utils/screen.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAKpC;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,OAAO,CAKrC;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,UAAU,GAAG,WAAW,CAEzD;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,IAAI,CAMjD"}