@use-voltra/ios-client 1.4.1 → 2.0.0-rc.1

package/expo-plugin/src/utils/urlScheme.ts

@@ -0,0 +1,45 @@
+import type { ExpoConfig } from 'expo/config'
+
+/**
+ * Ensures the main app has a URL scheme set so widgetURL can open it.
+ * This is an optional feature for deep linking from widgets.
+ *
+ * @param config - The Expo config object
+ * @returns The modified config with URL scheme ensured
+ */
+export function ensureURLScheme(config: ExpoConfig): ExpoConfig {
+  const scheme = typeof (config as any).scheme === 'string' ? (config as any).scheme : config.ios?.bundleIdentifier
+
+  if (!scheme) {
+    return config
+  }
+
+  const existingInfoPlist = config.ios?.infoPlist || {}
+  const existingTypes = (existingInfoPlist.CFBundleURLTypes as any[]) || []
+
+  // Check if scheme already exists
+  const hasScheme = existingTypes.some(
+    (t) => Array.isArray(t?.CFBundleURLSchemes) && t.CFBundleURLSchemes.includes(scheme)
+  )
+
+  if (hasScheme) {
+    return config
+  }
+
+  // Add the URL scheme
+  return {
+    ...config,
+    ios: {
+      ...config.ios,
+      infoPlist: {
+        ...existingInfoPlist,
+        CFBundleURLTypes: [
+          ...existingTypes,
+          {
+            CFBundleURLSchemes: [scheme],
+          },
+        ],
+      },
+    },
+  }
+}

package/expo-plugin/src/validation.node.test.ts

@@ -0,0 +1,19 @@
+import { validateIOSConfigPluginProps } from './validation'
+
+describe('validateIOSConfigPluginProps', () => {
+  it('accepts valid groupIdentifier', () => {
+    expect(() =>
+      validateIOSConfigPluginProps({
+        groupIdentifier: 'group.com.example.app',
+      })
+    ).not.toThrow()
+  })
+
+  it('rejects groupIdentifier without group. prefix', () => {
+    expect(() =>
+      validateIOSConfigPluginProps({
+        groupIdentifier: 'com.example.app',
+      })
+    ).toThrow(/must start with 'group.'/)
+  })
+})

package/expo-plugin/src/validation.ts

@@ -0,0 +1,63 @@
+import { validateHomeScreenWidgetId, validateInitialStatePath, validateWidgetLabel } from '@use-voltra/expo-plugin'
+
+import type { IOSConfigPluginProps, IOSWidgetConfig, IOSWidgetFamily } from './types'
+
+const VALID_FAMILIES: Set<IOSWidgetFamily> = new Set([
+  'systemSmall',
+  'systemMedium',
+  'systemLarge',
+  'systemExtraLarge',
+  'accessoryCircular',
+  'accessoryRectangular',
+  'accessoryInline',
+])
+
+export function validateIOSWidgetConfig(widget: IOSWidgetConfig): void {
+  validateHomeScreenWidgetId(widget.id)
+  validateWidgetLabel(widget.displayName, widget.id, 'displayName')
+  validateWidgetLabel(widget.description, widget.id, 'description')
+  validateInitialStatePath(widget.initialStatePath, widget.id)
+
+  if (widget.supportedFamilies) {
+    if (!Array.isArray(widget.supportedFamilies)) {
+      throw new Error(`Widget '${widget.id}': supportedFamilies must be an array`)
+    }
+
+    for (const family of widget.supportedFamilies) {
+      if (!VALID_FAMILIES.has(family)) {
+        throw new Error(
+          `Widget '${widget.id}': Invalid widget family '${family}'. ` +
+            `Valid families are: ${Array.from(VALID_FAMILIES).join(', ')}`
+        )
+      }
+    }
+  }
+}
+
+export function validateIOSConfigPluginProps(props: IOSConfigPluginProps): void {
+  if (props.groupIdentifier !== undefined) {
+    if (typeof props.groupIdentifier !== 'string') {
+      throw new Error('groupIdentifier must be a string')
+    }
+
+    if (!props.groupIdentifier.startsWith('group.')) {
+      throw new Error(`groupIdentifier '${props.groupIdentifier}' must start with 'group.'`)
+    }
+  }
+
+  if (props.widgets !== undefined) {
+    if (!Array.isArray(props.widgets)) {
+      throw new Error('widgets must be an array')
+    }
+
+    const seenIds = new Set<string>()
+    for (const widget of props.widgets) {
+      validateIOSWidgetConfig(widget)
+
+      if (seenIds.has(widget.id)) {
+        throw new Error(`Duplicate widget ID: '${widget.id}'`)
+      }
+      seenIds.add(widget.id)
+    }
+  }
+}

package/expo-plugin/tsconfig.base.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "rootDir": "./src",
+    "moduleResolution": "node",
+    "jsx": "react-jsx",
+    "strict": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*", "**/*.node.test.ts"]
+}

package/expo-plugin/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "outDir": "./build/cjs",
+    "declaration": false,
+    "sourceMap": true
+  }
+}

package/expo-plugin/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "outDir": "./build/esm",
+    "declaration": false,
+    "sourceMap": true
+  }
+}

package/expo-plugin/tsconfig.jest.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["jest", "node"]
+  },
+  "include": ["./src/**/*.ts"]
+}

package/expo-plugin/tsconfig.typecheck.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "rootDir": "../../..",
+    "baseUrl": "../../..",
+    "paths": {
+      "@use-voltra/expo-plugin": ["packages/expo-plugin/src/index.ts"]
+    }
+  },
+  "include": ["./src"]
+}

package/expo-plugin/tsconfig.types.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ES2020",
+    "outDir": "./build/types",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": true
+  }
+}

package/ios/Package.swift

@@ -0,0 +1,68 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+  name: "VoltraNativeTests",
+  platforms: [
+    .iOS(.v16),
+    .macOS(.v13),
+  ],
+  products: [
+    .library(
+      name: "VoltraSharedCore",
+      targets: ["VoltraSharedCore"]
+    ),
+    .library(
+      name: "VoltraStyleCore",
+      targets: ["VoltraStyleCore"]
+    ),
+  ],
+  targets: [
+    .target(
+      name: "VoltraSharedCore",
+      path: "shared",
+      exclude: [
+        "BrotliCompression.swift",
+        "Data+hexString.swift",
+        "Date+toTimerInterval.swift",
+        "ShortNames.swift",
+        "VoltraAttributes.swift",
+        "VoltraConfig.swift",
+        "VoltraElement.swift",
+        "VoltraEvent.swift",
+        "VoltraEventBus.swift",
+        "VoltraImageStore.swift",
+        "VoltraInteractionIntent.swift",
+        "VoltraLiveActivityPayload.swift",
+        "VoltraNode.swift",
+        "VoltraPersistentEventQueue.swift",
+      ],
+      sources: [
+        "JSONValue.swift",
+        "VoltraPayloadMigrator.swift",
+        "VoltraRegion.swift",
+        "ComponentTypeID.swift",
+      ]
+    ),
+    .testTarget(
+      name: "VoltraSharedTests",
+      dependencies: ["VoltraSharedCore"],
+      path: "Tests/VoltraSharedTests"
+    ),
+    .target(
+      name: "VoltraStyleCore",
+      path: "ui",
+      sources: [
+        "Style/BackgroundValue.swift",
+        "Style/JSColorParser.swift",
+        "Style/JSGradientParser.swift",
+      ]
+    ),
+    .testTarget(
+      name: "VoltraStyleTests",
+      dependencies: ["VoltraStyleCore"],
+      path: "tests",
+      sources: ["JSGradientParserTests.swift"]
+    ),
+  ]
+)

package/ios/Tests/JSGradientParserTests.swift

@@ -0,0 +1,201 @@
+import SwiftUI
+@testable import VoltraStyleCore
+import XCTest
+
+final class JSGradientParserTests: XCTestCase {
+  private func assertLinearGradient(
+    _ value: String,
+    file: StaticString = #filePath,
+    line: UInt = #line,
+    _ assertions: (_ stops: [Gradient.Stop], _ start: UnitPoint, _ end: UnitPoint) -> Void
+  ) {
+    let parsed = JSGradientParser.parse(value)
+    guard case let .linearGradient(gradient, startPoint, endPoint)? = parsed else {
+      XCTFail("Expected linear gradient for: \(value), got: \(String(describing: parsed))", file: file, line: line)
+      return
+    }
+    assertions(gradient.stops, startPoint, endPoint)
+  }
+
+  private func assertRadialGradient(
+    _ value: String,
+    file: StaticString = #filePath,
+    line: UInt = #line,
+    _ assertions: (_ spec: RadialGradientSpec) -> Void
+  ) {
+    let parsed = JSGradientParser.parse(value)
+    guard case let .radialGradient(spec)? = parsed else {
+      XCTFail("Expected radial gradient for: \(value), got: \(String(describing: parsed))", file: file, line: line)
+      return
+    }
+    assertions(spec)
+  }
+
+  private func assertConicGradient(
+    _ value: String,
+    file: StaticString = #filePath,
+    line: UInt = #line,
+    _ assertions: (_ stops: [Gradient.Stop], _ center: UnitPoint, _ angle: Angle) -> Void
+  ) {
+    guard case let .angularGradient(gradient, center, angle)? = JSGradientParser.parse(value) else {
+      XCTFail("Expected conic gradient for: \(value)", file: file, line: line)
+      return
+    }
+    assertions(gradient.stops, center, angle)
+  }
+
+  func testLinearGradientWithRGBAStopsParses() {
+    let value = "linear-gradient(to right, rgba(255,0,0,0.8) 0%, rgba(0,0,255,0.3) 100%)"
+    XCTAssertNotNil(JSGradientParser.parse(value))
+  }
+
+  func testLinearGradientWithSpaceSlashRGBAParses() {
+    let value = "linear-gradient(90deg, rgba(255 0 0 / 80%) 0%, rgba(0 0 255 / 30%) 100%)"
+    XCTAssertNotNil(JSGradientParser.parse(value))
+  }
+
+  func testRadialGradientWithRGBAAndTransparentParses() {
+    let value = "radial-gradient(circle at center, rgba(255,0,0,.8) 10%, transparent 90%)"
+    XCTAssertNotNil(JSGradientParser.parse(value))
+  }
+
+  func testConicGradientWithDegreeStopsParses() {
+    let value = "conic-gradient(from 90deg at center, rgba(255,0,0,.8) 0deg, rgba(0,0,255,.3) 360deg)"
+    XCTAssertNotNil(JSGradientParser.parse(value))
+  }
+
+  func testInvalidColorTokenWithTrailingGarbageFails() {
+    let value = "linear-gradient(to right, rgba(255,0,0,0.8)garbage 0%, blue 100%)"
+    XCTAssertNil(JSGradientParser.parse(value))
+  }
+
+  func testMalformedParenthesesFails() {
+    let value = "linear-gradient(to right, rgba(255,0,0,0.8 0%, blue 100%)"
+    XCTAssertNil(JSGradientParser.parse(value))
+  }
+
+  func testBadStopTokenFails() {
+    let value = "linear-gradient(to right, red badstop, blue 100%)"
+    XCTAssertNil(JSGradientParser.parse(value))
+  }
+
+  func testLinearGradientDirectionParsesExpectedStartAndEndPoints() {
+    assertLinearGradient("linear-gradient(to bottom right, rgba(255,0,0,1) 0%, rgba(0,0,255,1) 100%)") { _, start, end in
+      XCTAssertEqual(start.x, 0, accuracy: 0.0001)
+      XCTAssertEqual(start.y, 0, accuracy: 0.0001)
+      XCTAssertEqual(end.x, 1, accuracy: 0.0001)
+      XCTAssertEqual(end.y, 1, accuracy: 0.0001)
+    }
+  }
+
+  func testLinearGradientAngleParsesExpectedStartAndEndPoints() {
+    assertLinearGradient("linear-gradient(90deg, rgba(255,0,0,1) 0%, rgba(0,0,255,1) 100%)") { _, start, end in
+      XCTAssertEqual(start.x, 0, accuracy: 0.0001)
+      XCTAssertEqual(start.y, 0.5, accuracy: 0.0001)
+      XCTAssertEqual(end.x, 1, accuracy: 0.0001)
+      XCTAssertEqual(end.y, 0.5, accuracy: 0.0001)
+    }
+  }
+
+  func testDoublePositionStopExpandsIntoTwoStops() {
+    assertLinearGradient("linear-gradient(to right, red 10% 30%, blue 100%)") { stops, _, _ in
+      XCTAssertEqual(stops.count, 3)
+      XCTAssertEqual(stops[0].location, 0.1, accuracy: 0.0001)
+      XCTAssertEqual(stops[1].location, 0.3, accuracy: 0.0001)
+      XCTAssertEqual(stops[2].location, 1, accuracy: 0.0001)
+    }
+  }
+
+  func testStopPositionsClampToNonDecreasingOrder() {
+    assertLinearGradient("linear-gradient(to right, red 70%, green 30%, blue 100%)") { stops, _, _ in
+      XCTAssertEqual(stops.count, 3)
+      XCTAssertEqual(stops[0].location, 0.7, accuracy: 0.0001)
+      XCTAssertEqual(stops[1].location, 0.7, accuracy: 0.0001)
+      XCTAssertEqual(stops[2].location, 1, accuracy: 0.0001)
+    }
+  }
+
+  func testRadialGradientPreludeParsesShapeExtentAndCenter() {
+    assertRadialGradient("radial-gradient(circle closest-side at top right, red 0%, blue 100%)") { spec in
+      guard case .circle = spec.shape else {
+        XCTFail("Expected circle radial shape")
+        return
+      }
+      guard case .closestSide = spec.extent else {
+        XCTFail("Expected closest-side radial extent")
+        return
+      }
+      XCTAssertEqual(spec.center.x, 1, accuracy: 0.0001)
+      XCTAssertEqual(spec.center.y, 0, accuracy: 0.0001)
+      XCTAssertEqual(spec.gradient.stops.count, 2)
+    }
+  }
+
+  func testConicGradientPreludeParsesAngleAndCenter() {
+    assertConicGradient("conic-gradient(from 0.25turn at left bottom, red 0%, blue 100%)") { stops, center, angle in
+      XCTAssertEqual(stops.count, 2)
+      XCTAssertEqual(center.x, 0, accuracy: 0.0001)
+      XCTAssertEqual(center.y, 1, accuracy: 0.0001)
+      XCTAssertEqual(angle.degrees, 90, accuracy: 0.0001)
+    }
+  }
+
+  func testConicGradientDegreeStopsMapToUnitInterval() {
+    assertConicGradient("conic-gradient(from 0deg at center, red 90deg, blue 270deg)") { stops, _, _ in
+      XCTAssertEqual(stops.count, 2)
+      XCTAssertEqual(stops[0].location, 0.25, accuracy: 0.0001)
+      XCTAssertEqual(stops[1].location, 0.75, accuracy: 0.0001)
+    }
+  }
+
+  func testRepeatingGradientsAreRejected() {
+    XCTAssertNil(JSGradientParser.parse("repeating-linear-gradient(to right, red, blue)"))
+    XCTAssertNil(JSGradientParser.parse("repeating-radial-gradient(circle, red, blue)"))
+    XCTAssertNil(JSGradientParser.parse("repeating-conic-gradient(from 45deg, red, blue)"))
+  }
+
+  func testInvalidRadialPreludeFails() {
+    XCTAssertNil(JSGradientParser.parse("radial-gradient(circle foo at center, red, blue)"))
+  }
+
+  func testConicStopsWithPercentAndAngleProduceExpandedStops() {
+    assertConicGradient("conic-gradient(from 0deg at center, red 25% 90deg, blue 100%)") { stops, _, _ in
+      XCTAssertEqual(stops.count, 3)
+      XCTAssertEqual(stops[0].location, 0.25, accuracy: 0.0001)
+      XCTAssertEqual(stops[1].location, 0.25, accuracy: 0.0001)
+      XCTAssertEqual(stops[2].location, 1, accuracy: 0.0001)
+    }
+  }
+}
+
+final class JSColorParserTests: XCTestCase {
+  func testNamedColorsParse() {
+    XCTAssertNotNil(JSColorParser.parse("red"))
+    XCTAssertNotNil(JSColorParser.parse("green"))
+    XCTAssertNotNil(JSColorParser.parse("blue"))
+  }
+
+  func testRGBSlashSyntaxParses() {
+    XCTAssertNotNil(JSColorParser.parse("rgb(255 0 0 / 80%)"))
+    XCTAssertNotNil(JSColorParser.parse("rgba(255 0 0 / 0.8)"))
+    XCTAssertNotNil(JSColorParser.parse("hsl(240 100% 50% / 30%)"))
+  }
+
+  func testTrailingGarbageRejected() {
+    XCTAssertNil(JSColorParser.parse("rgba(255,0,0,0.8)garbage"))
+    XCTAssertNil(JSColorParser.parse("rgb(255,0)"))
+    XCTAssertNil(JSColorParser.parse("hsl(120, 100, 50%)"))
+  }
+
+  func testReducedPresentationPrimaryColorDetectionTreatsNeutralColorsAsAdaptive() {
+    XCTAssertTrue(JSColorParser.shouldUsePrimaryColorInReducedPresentation("#F9FAFB"))
+    XCTAssertTrue(JSColorParser.shouldUsePrimaryColorInReducedPresentation("#6B7280"))
+    XCTAssertTrue(JSColorParser.shouldUsePrimaryColorInReducedPresentation("white"))
+  }
+
+  func testReducedPresentationPrimaryColorDetectionPreservesSemanticAccents() {
+    XCTAssertFalse(JSColorParser.shouldUsePrimaryColorInReducedPresentation("#34D399"))
+    XCTAssertFalse(JSColorParser.shouldUsePrimaryColorInReducedPresentation("#F87171"))
+    XCTAssertFalse(JSColorParser.shouldUsePrimaryColorInReducedPresentation("green"))
+  }
+}

package/ios/Tests/VoltraSharedTests/SmokeTests.swift

@@ -0,0 +1,8 @@
+@testable import VoltraSharedCore
+import XCTest
+
+final class SmokeTests: XCTestCase {
+  func testOneEqualsOne() {
+    XCTAssertEqual(1, 1)
+  }
+}

package/ios/VoltraWidget.podspec

@@ -0,0 +1,30 @@
+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/NativeVoltra.h

@@ -0,0 +1,5 @@
+#import <VoltraSpec/VoltraSpec.h>
+
+@interface NativeVoltra : NativeVoltraSpecBase <NativeVoltraSpec>
+
+@end