voltra 1.4.1 → 2.0.0-rc.3

package/build/types/widgets/server-credentials.d.ts

@@ -1,49 +0,0 @@
-import type { WidgetServerCredentials } from '../types.js';
-export type { WidgetServerCredentials } from '../types.js';
-/**
- * Store server credentials for widget server-driven updates.
- *
- * On iOS, credentials are stored in the Shared Keychain (accessible by both the
- * main app and widget extension) with `kSecAttrAccessibleAfterFirstUnlock` to allow
- * background access.
- *
- * On Android, credentials are encrypted via Google Tink (AES-256-GCM) and
- * persisted in Jetpack DataStore. The encryption key is managed by the Android
- * Keystore. The WorkManager background worker can access this storage directly
- * since widgets are part of the main app binary.
- *
- * Call this after the user logs in to enable authenticated widget updates.
- *
- * @param credentials - The server credentials to store
- *
- * @example
- * ```typescript
- * import { setWidgetServerCredentials } from 'voltra'
- *
- * // After user login
- * await setWidgetServerCredentials({
- *   token: userAccessToken,
- *   headers: {
- *     'X-App-Version': '1.0.0',
- *   }
- * })
- * ```
- */
-export declare function setWidgetServerCredentials(credentials: WidgetServerCredentials): Promise<void>;
-/**
- * Clear stored server credentials for widget updates.
- *
- * Call this when the user logs out to stop authenticated widget updates.
- * All widgets are automatically reloaded after clearing credentials so they
- * revert to their default/unauthenticated state.
- *
- * @example
- * ```typescript
- * import { clearWidgetServerCredentials } from 'voltra'
- *
- * // On user logout
- * await clearWidgetServerCredentials()
- * ```
- */
-export declare function clearWidgetServerCredentials(): Promise<void>;
-//# sourceMappingURL=server-credentials.d.ts.map

package/build/types/widgets/server-credentials.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"server-credentials.d.ts","sourceRoot":"","sources":["../../../src/widgets/server-credentials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAI1D,YAAY,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,0BAA0B,CAAC,WAAW,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMpG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,IAAI,CAAC,CAElE"}

package/build/types/widgets/types.d.ts

@@ -1,39 +0,0 @@
-import type { ReactNode } from 'react';
-/**
- * Widget size families supported by iOS
- */
-export type WidgetFamily = 'systemSmall' | 'systemMedium' | 'systemLarge' | 'systemExtraLarge' | 'accessoryCircular' | 'accessoryRectangular' | 'accessoryInline';
-/**
- * Widget variants following the same pattern as LiveActivityVariants.
- * Each key corresponds to a widget family.
- */
-export type WidgetVariants = Partial<Record<WidgetFamily, ReactNode>>;
-/**
- * Information about an active widget configuration on iOS
- */
-export interface WidgetInfo {
-    /** The name (ID) of the widget as defined in the config plugin */
-    name: string;
-    /** The 'kind' string defined in your WidgetExtension */
-    kind: string;
-    /** The visual size of the widget */
-    family: WidgetFamily;
-}
-/**
- * A single entry in a widget timeline with scheduled display time and content
- */
-export type ScheduledWidgetEntry = {
-    /**
-     * When this content should be displayed
-     */
-    date: Date;
-    /**
-     * Widget content for different size families
-     */
-    variants: WidgetVariants;
-    /**
-     * Optional deep link URL for this specific entry
-     */
-    deepLinkUrl?: string;
-};
-//# sourceMappingURL=types.d.ts.map

package/build/types/widgets/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/widgets/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,aAAa,GACb,cAAc,GACd,aAAa,GACb,kBAAkB,GAClB,mBAAmB,GACnB,sBAAsB,GACtB,iBAAiB,CAAA;AAErB;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,CAAA;AAErE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAA;IACZ,oCAAoC;IACpC,MAAM,EAAE,YAAY,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC;;OAEG;IACH,IAAI,EAAE,IAAI,CAAA;IACV;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAA;IACxB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA"}

package/build/types/widgets/widget-api.d.ts

@@ -1,146 +0,0 @@
-import type { UpdateWidgetOptions } from '../types.js';
-import { ScheduledWidgetEntry, WidgetInfo, WidgetVariants } from './types.js';
-export type { UpdateWidgetOptions } from '../types.js';
-export type { ScheduledWidgetEntry, WidgetInfo } from './types.js';
-/**
- * Update a home screen widget with new content.
- *
- * The content will be stored in App Group storage and the widget timeline
- * will be reloaded to display the new content.
- *
- * @param widgetId - The widget identifier (as defined in your config plugin)
- * @param variants - An object mapping widget families to specific content.
- *   Each key corresponds to a widget size family.
- * @param options - Optional settings like deep link URL
- *
- * @example Different content per size
- * ```tsx
- * import { updateWidget, Voltra } from 'voltra'
- *
- * await updateWidget('weather', {
- *   systemSmall: <Voltra.Text fontSize={32}>72°F</Voltra.Text>,
- *   systemMedium: (
- *     <Voltra.HStack>
- *       <Voltra.Text fontSize={32}>72°F</Voltra.Text>
- *       <Voltra.VStack>
- *         <Voltra.Text>Sunny</Voltra.Text>
- *         <Voltra.Text>High: 78° Low: 65°</Voltra.Text>
- *       </Voltra.VStack>
- *     </Voltra.HStack>
- *   ),
- * }, { deepLinkUrl: '/weather' })
- * ```
- */
-export declare const updateWidget: (widgetId: string, variants: WidgetVariants, options?: UpdateWidgetOptions) => Promise<void>;
-/**
- * Reload widget timelines to refresh their content.
- *
- * Use this after updating data that widgets depend on (e.g., after preloading
- * new images) to force them to re-render.
- *
- * @param widgetIds - Optional array of widget IDs to reload. If omitted, reloads all widgets.
- *
- * @example
- * ```typescript
- * // Reload specific widgets
- * await reloadWidgets(['weather', 'calendar'])
- *
- * // Reload all widgets
- * await reloadWidgets()
- * ```
- */
-export declare const reloadWidgets: (widgetIds?: string[]) => Promise<void>;
-/**
- * Clear a widget's stored data.
- *
- * This removes the JSON content and deep link URL for the specified widget,
- * causing it to show its placeholder state.
- *
- * @param widgetId - The widget identifier to clear
- *
- * @example
- * ```typescript
- * await clearWidget('weather')
- * ```
- */
-export declare const clearWidget: (widgetId: string) => Promise<void>;
-/**
- * Clear all widgets' stored data.
- *
- * This removes the JSON content and deep link URLs for all configured widgets,
- * causing them to show their placeholder states.
- *
- * @example
- * ```typescript
- * await clearAllWidgets()
- * ```
- */
-export declare const clearAllWidgets: () => Promise<void>;
-/**
- * Schedule a widget timeline with multiple entries to be displayed at future times.
- *
- * iOS will automatically display each entry at its scheduled time, even when your
- * app is not running. This allows you to batch widget updates in advance.
- *
- * @param widgetId - The widget identifier (as defined in your config plugin)
- * @param entries - Array of scheduled entries, each with a date and content variants
- * @param options - Optional settings like reload policy
- *
- * @example Schedule weather updates throughout the day
- * ```tsx
- * import { scheduleWidget, Voltra } from 'voltra'
- *
- * await scheduleWidget('weather', [
- *   {
- *     date: new Date('2026-01-16T09:00:00'),
- *     variants: {
- *       systemSmall: <Voltra.Text>Morning: 65°F</Voltra.Text>
- *     }
- *   },
- *   {
- *     date: new Date('2026-01-16T15:00:00'),
- *     variants: {
- *       systemSmall: <Voltra.Text>Afternoon: 72°F</Voltra.Text>
- *     }
- *   },
- *   {
- *     date: new Date('2026-01-16T21:00:00'),
- *     variants: {
- *       systemSmall: <Voltra.Text>Evening: 68°F</Voltra.Text>
- *     }
- *   }
- * ], {
- *   policy: { type: 'atEnd' } // Request new timeline when last entry expires
- * })
- * ```
- *
- * @example With deep links per entry
- * ```tsx
- * await scheduleWidget('news', [
- *   {
- *     date: new Date('2026-01-16T08:00:00'),
- *     variants: { systemSmall: <Voltra.Text>Morning News</Voltra.Text> },
- *     deepLinkUrl: '/news/morning'
- *   },
- *   {
- *     date: new Date('2026-01-16T20:00:00'),
- *     variants: { systemSmall: <Voltra.Text>Evening News</Voltra.Text> },
- *     deepLinkUrl: '/news/evening'
- *   }
- * ])
- * ```
- */
-export declare const scheduleWidget: (widgetId: string, entries: ScheduledWidgetEntry[]) => Promise<void>;
-/**
- * Fetches all active widget configurations for the containing app on iOS.
- *
- * @returns A promise that resolves to an array of active widget configurations.
- *
- * @example
- * ```typescript
- * const widgets = await getActiveWidgets()
- * console.log('Active widgets:', widgets)
- * ```
- */
-export declare const getActiveWidgets: () => Promise<WidgetInfo[]>;
-//# sourceMappingURL=widget-api.d.ts.map

package/build/types/widgets/widget-api.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"widget-api.d.ts","sourceRoot":"","sources":["../../../src/widgets/widget-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAItD,OAAO,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAG7E,YAAY,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACtD,YAAY,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,EAChB,UAAU,cAAc,EACxB,UAAU,mBAAmB,KAC5B,OAAO,CAAC,IAAI,CAQd,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAU,YAAY,MAAM,EAAE,KAAG,OAAO,CAAC,IAAI,CAItE,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAU,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAIhE,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,QAAa,OAAO,CAAC,IAAI,CAIpD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,cAAc,GAAU,UAAU,MAAM,EAAE,SAAS,oBAAoB,EAAE,KAAG,OAAO,CAAC,IAAI,CAmBpG,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,QAAa,OAAO,CAAC,UAAU,EAAE,CAI7D,CAAA"}

package/expo-module.config.json

@@ -1,9 +0,0 @@
-{
-  "platforms": ["apple", "android", "web"],
-  "apple": {
-    "modules": ["VoltraModule"]
-  },
-  "android": {
-    "modules": ["voltra.VoltraModule"]
-  }
-}

package/ios/Voltra.podspec

@@ -1,32 +0,0 @@
-require 'json'
-
-package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
-
-Pod::Spec.new do |s|
-  s.name           = 'Voltra'
-  s.version        = package['version']
-  s.summary        = package['description']
-  s.description    = 'Build dynamic iOS Live Activities and interact with the Dynamic Island directly from React Native. No Swift, no Xcode, no hassle.'
-  s.license        = package['license']
-  s.author         = package['author']
-  s.homepage       = package['homepage']
-  s.platforms      = {
-    :ios => '16.2',
-  }
-  s.swift_version  = '5.9'
-  s.source         = { git: 'https://github.com/callstackincubator/voltra' }
-  s.static_framework = true
-
-  # Swift/Objective-C compatibility
-  s.pod_target_xcconfig = {
-    'DEFINES_MODULE' => 'YES',
-  }
-
-  s.dependency 'ExpoModulesCore'
-
-  s.source_files = [
-    "app/**/*.swift",
-    "ui/**/*.swift",
-    "shared/**/*.swift",
-  ]
-end

package/ios/VoltraWidget.podspec

@@ -1,30 +0,0 @@
-require 'json'
-
-package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
-
-Pod::Spec.new do |s|
-  s.name           = 'VoltraWidget'
-  s.version        = package['version']
-  s.summary        = package['description']
-  s.description    = 'Voltra Widget Extension support.'
-  s.license        = package['license']
-  s.author         = package['author']
-  s.homepage       = package['homepage']
-  s.platforms      = {
-    :ios => '16.2',
-  }
-  s.swift_version  = '5.9'
-  s.source         = { git: 'https://github.com/callstackincubator/voltra' }
-  s.static_framework = true
-
-  # Swift/Objective-C compatibility
-  s.pod_target_xcconfig = {
-    'DEFINES_MODULE' => 'YES',
-  }
-
-  s.source_files = [
-    "ui/**/*.swift",
-    "shared/**/*.swift",
-    "target/**/*.swift",
-  ]
-end

package/ios/app/VoltraActivity.swift

@@ -1,5 +0,0 @@
-import ActivityKit
-import Foundation
-
-/// Type alias for Live Activity with unified attributes
-public typealias VoltraActivity = Activity<VoltraAttributes>

package/ios/app/VoltraImagePreload.swift

@@ -1,166 +0,0 @@
-import ExpoModulesCore
-import Foundation
-import os
-import UIKit
-
-// MARK: - Types
-
-/// Options for preloading a single image
-public struct PreloadImageOptions: Record {
-  /// The URL to download the image from
-  @Field
-  public var url: String
-
-  /// The key to use when referencing this image (used as assetName)
-  @Field
-  public var key: String
-
-  /// HTTP method to use (GET, POST, PUT). Defaults to GET.
-  @Field
-  public var method: String?
-
-  /// Optional HTTP headers to include in the request
-  @Field
-  public var headers: [String: String]?
-
-  public init() {}
-}
-
-/// Result of a failed image preload
-public struct PreloadImageFailure: Record {
-  @Field
-  public var key: String
-
-  @Field
-  public var error: String
-
-  public init() {}
-
-  public init(key: String, error: String) {
-    self.key = key
-    self.error = error
-  }
-}
-
-/// Result of preloading images
-public struct PreloadImagesResult: Record {
-  @Field
-  public var succeeded: [String]
-
-  @Field
-  public var failed: [PreloadImageFailure]
-
-  public init() {}
-
-  public init(succeeded: [String], failed: [PreloadImageFailure]) {
-    self.succeeded = succeeded
-    self.failed = failed
-  }
-}
-
-// MARK: - Errors
-
-/// Errors that can occur during image preloading
-enum PreloadError: Error, LocalizedError {
-  case invalidURL(String)
-  case invalidResponse
-  case httpError(statusCode: Int)
-  case imageTooLarge(key: String, size: Int)
-  case invalidImageData(key: String)
-  case appGroupNotConfigured
-
-  var errorDescription: String? {
-    switch self {
-    case let .invalidURL(url):
-      return "Invalid URL: \(url)"
-    case .invalidResponse:
-      return "Invalid response from server"
-    case let .httpError(statusCode):
-      return "HTTP error: \(statusCode)"
-    case let .imageTooLarge(key, size):
-      return "Image '\(key)' is too large: \(size) bytes (max \(VoltraImagePreload.maxImageSizeInBytes) bytes for Live Activities)"
-    case let .invalidImageData(key):
-      return "Invalid image data for '\(key)'"
-    case .appGroupNotConfigured:
-      return "App Group not configured. Set 'groupIdentifier' in the Voltra config plugin."
-    }
-  }
-}
-
-// MARK: - Namespace
-
-enum VoltraImagePreload {
-  static let maxImageSizeInBytes = 4096
-
-  static func preloadImages(images: [PreloadImageOptions]) async throws -> PreloadImagesResult {
-    var succeeded: [String] = []
-    var failed: [PreloadImageFailure] = []
-
-    for imageOptions in images {
-      do {
-        try await downloadAndSaveImage(imageOptions)
-        succeeded.append(imageOptions.key)
-      } catch {
-        failed.append(PreloadImageFailure(key: imageOptions.key, error: error.localizedDescription))
-      }
-    }
-
-    return PreloadImagesResult(succeeded: succeeded, failed: failed)
-  }
-
-  static func clearPreloadedImages(keys: [String]?) async {
-    if let keys = keys, !keys.isEmpty {
-      VoltraImageStore.removeImages(keys: keys)
-      VoltraLogger.image.info("Cleared preloaded images: \(keys.joined(separator: ", "))")
-    } else {
-      VoltraImageStore.clearAll()
-      VoltraLogger.image.info("Cleared all preloaded images")
-    }
-  }
-
-  // MARK: - Private
-
-  private static func downloadAndSaveImage(_ options: PreloadImageOptions) async throws {
-    guard let url = URL(string: options.url) else {
-      throw PreloadError.invalidURL(options.url)
-    }
-
-    var request = URLRequest(url: url)
-    request.httpMethod = options.method ?? "GET"
-
-    if let headers = options.headers {
-      for (key, value) in headers {
-        request.setValue(value, forHTTPHeaderField: key)
-      }
-    }
-
-    let (data, response) = try await URLSession.shared.data(for: request)
-
-    guard let httpResponse = response as? HTTPURLResponse else {
-      throw PreloadError.invalidResponse
-    }
-
-    guard (200 ... 299).contains(httpResponse.statusCode) else {
-      throw PreloadError.httpError(statusCode: httpResponse.statusCode)
-    }
-
-    if let contentLengthString = httpResponse.value(forHTTPHeaderField: "Content-Length"),
-       let contentLength = Int(contentLengthString)
-    {
-      if contentLength >= maxImageSizeInBytes {
-        throw PreloadError.imageTooLarge(key: options.key, size: contentLength)
-      }
-    }
-
-    if data.count >= maxImageSizeInBytes {
-      throw PreloadError.imageTooLarge(key: options.key, size: data.count)
-    }
-
-    guard UIImage(data: data) != nil else {
-      throw PreloadError.invalidImageData(key: options.key)
-    }
-
-    try VoltraImageStore.saveImage(data, key: options.key)
-    VoltraLogger.image.info("Preloaded '\(options.key)' (\(data.count) bytes)")
-  }
-}