Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

5.3 KB
Raw Blame
import * as DocumentPicker from 'expo-document-picker'
import { File as FsFile } from 'expo-file-system'
import * as ImagePicker from 'expo-image-picker'
import {
  CLIPBOARD_IMAGE_MAX_SOURCE_BYTES,
  assertClipboardImageBase64LengthWithinLimit,
  assertClipboardImageByteLengthWithinLimit
} from '../../../src/shared/clipboard-image'
import { MobileImageBase64Accumulator } from './mobile-image-base64-accumulator'
import { isPickedImageMime } from '../platform/mobile-picked-file-name'
// Import permission errors from the Expo-free contract so page-side catches cannot pull native picker code into the bundle.
import { ImageLibraryPermissionError } from '../platform/media-picker-contract'
import type { MobileImageSource, PickedMobileImage } from '../platform/media-picker-contract'

export { ImageLibraryPermissionError }
export type { MobileImageSource, PickedMobileImage }

const MOBILE_IMAGE_READ_CHUNK_BYTES = 256 * 1024

type MobileImageFileHandle = {
  readonly size: number | null
  readBytes(length: number): Uint8Array
  close(): void
}

type MobileImageFile = {
  readonly size: number
  open(): MobileImageFileHandle
}

export type MobileImageFileFactory = (uri: string) => MobileImageFile

export function defaultMobileImageFileFactory(uri: string): MobileImageFile {
  return new FsFile(uri)
}

export async function readUriAsBase64(
  uri: string,
  declaredSize: number | undefined | null,
  createFile: MobileImageFileFactory,
  assertBytes: (byteLength: number) => void = assertClipboardImageByteLengthWithinLimit
): Promise<string> {
  if (typeof declaredSize === 'number' && Number.isFinite(declaredSize)) {
    assertBytes(declaredSize)
  }

  const file = createFile(uri)
  assertBytes(file.size)
  const handle = file.open()
  try {
    if (handle.size !== null) {
      assertBytes(handle.size)
    }
    const accumulator = new MobileImageBase64Accumulator()
    let bytesRead = 0
    while (bytesRead <= CLIPBOARD_IMAGE_MAX_SOURCE_BYTES) {
      const requested = Math.min(
        MOBILE_IMAGE_READ_CHUNK_BYTES,
        CLIPBOARD_IMAGE_MAX_SOURCE_BYTES - bytesRead + 1
      )
      const bytes = handle.readBytes(requested)
      if (bytes.byteLength === 0) {
        break
      }
      bytesRead += bytes.byteLength
      assertBytes(bytesRead)
      accumulator.append(bytes)
    }
    const base64 = accumulator.finish()
    assertClipboardImageBase64LengthWithinLimit(base64.length)
    return base64
  } finally {
    handle.close()
  }
}

async function* pickFromLibrary(
  multiple: boolean,
  requestPermission: typeof ImagePicker.requestMediaLibraryPermissionsAsync = ImagePicker.requestMediaLibraryPermissionsAsync,
  launch: typeof ImagePicker.launchImageLibraryAsync = ImagePicker.launchImageLibraryAsync,
  createFile: MobileImageFileFactory = defaultMobileImageFileFactory
): AsyncGenerator<PickedMobileImage> {
  const permission = await requestPermission()
  // Why: `granted` covers full + limited iOS access; only a hard denial blocks us.
  if (!permission.granted) {
    throw new ImageLibraryPermissionError()
  }
  const result = await launch({
    mediaTypes: ['images'],
    base64: false,
    allowsMultipleSelection: multiple,
    ...(multiple ? { selectionLimit: 0, orderedSelection: true } : {}),
    quality: 1
  })
  if (result.canceled) {
    return
  }
  for (const asset of result.assets) {
    if (!asset.uri) {
      continue
    }
    const base64 = await readUriAsBase64(asset.uri, asset.fileSize, createFile)
    if (base64) {
      yield { base64, uri: asset.uri }
    }
  }
}

async function* pickFromFiles(
  multiple: boolean,
  launch: typeof DocumentPicker.getDocumentAsync = DocumentPicker.getDocumentAsync,
  createFile: MobileImageFileFactory = defaultMobileImageFileFactory
): AsyncGenerator<PickedMobileImage> {
  const result = await launch({
    type: '*/*',
    multiple,
    copyToCacheDirectory: true
  })
  if (result.canceled) {
    return
  }
  for (const asset of result.assets) {
    if (!asset.uri) {
      continue
    }
    const base64 = await readUriAsBase64(asset.uri, asset.size, createFile)
    if (base64) {
      const fileName = isPickedImageMime(asset.mimeType)
        ? undefined
        : asset.name.trim() || 'attachment'
      yield { base64, uri: asset.uri, fileName }
    }
  }
}

type MobileImagePickerDeps = {
  readonly requestLibraryPermission?: typeof ImagePicker.requestMediaLibraryPermissionsAsync
  readonly launchLibrary?: typeof ImagePicker.launchImageLibraryAsync
  readonly launchFiles?: typeof DocumentPicker.getDocumentAsync
  readonly createFile?: MobileImageFileFactory
}

function pickMobileImagesWithMode(
  source: MobileImageSource,
  multiple: boolean,
  deps?: MobileImagePickerDeps
): AsyncIterable<PickedMobileImage> {
  if (source === 'library') {
    return pickFromLibrary(
      multiple,
      deps?.requestLibraryPermission,
      deps?.launchLibrary,
      deps?.createFile
    )
  }
  return pickFromFiles(multiple, deps?.launchFiles, deps?.createFile)
}

export async function pickMobileImage(
  source: MobileImageSource,
  deps?: MobileImagePickerDeps
): Promise<PickedMobileImage | null> {
  for await (const image of pickMobileImagesWithMode(source, false, deps)) {
    return image
  }
  return null
}

export function pickMobileImages(
  source: MobileImageSource,
  deps?: MobileImagePickerDeps
): AsyncIterable<PickedMobileImage> {
  return pickMobileImagesWithMode(source, true, deps)
}