@symbiote-native/media-library 0.1.0

package/build/core/media-library.js

@@ -0,0 +1,284 @@
+import { createPermissionHook } from 'expo-modules-core';
+import { Platform } from 'react-native';
+import { expoMediaLibrary } from './native-module.js';
+function arrayize(item) {
+    if (Array.isArray(item))
+        return item;
+    return item ? [item] : [];
+}
+function getId(ref) {
+    if (typeof ref === 'string')
+        return ref;
+    return ref ? ref.id : undefined;
+}
+function assertAssetIds(assetIds) {
+    if (assetIds.some(id => !id || typeof id !== 'string')) {
+        throw new Error('Asset ID must be a string!');
+    }
+}
+function assertAlbumIds(albumIds) {
+    if (albumIds.some(id => !id || typeof id !== 'string')) {
+        throw new Error('Album ID must be a string!');
+    }
+}
+function assertMediaType(mediaType) {
+    if (!Object.values(MediaType).includes(mediaType)) {
+        throw new Error(`Invalid mediaType: ${String(mediaType)}`);
+    }
+}
+function assertSortByKey(sortBy) {
+    if (!Object.values(SortBy).includes(sortBy)) {
+        throw new Error(`Invalid sortBy key: ${String(sortBy)}`);
+    }
+}
+function assertSortBy(sortBy) {
+    if (Array.isArray(sortBy)) {
+        assertSortByKey(sortBy[0]);
+        if (typeof sortBy[1] !== 'boolean') {
+            throw new Error('Invalid sortBy array argument. Second item must be a boolean!');
+        }
+    }
+    else {
+        assertSortByKey(sortBy);
+    }
+}
+function sortByOptionToString(sortBy) {
+    assertSortBy(sortBy);
+    if (Array.isArray(sortBy)) {
+        return `${sortBy[0]} ${sortBy[1] ? 'ASC' : 'DESC'}`;
+    }
+    return `${sortBy} DESC`;
+}
+function dateToNumber(value) {
+    return value instanceof Date ? value.getTime() : value;
+}
+export const MediaType = expoMediaLibrary.MediaType;
+export const SortBy = expoMediaLibrary.SortBy;
+export async function isAvailableAsync() {
+    return !!expoMediaLibrary && 'getAssetsAsync' in expoMediaLibrary;
+}
+/**
+ * @param granularPermissions Only has an effect on Android 13+. Defaults to every possible
+ * permission — make sure your app manifest requests everything you pass here.
+ */
+export async function requestPermissionsAsync(writeOnly = false, granularPermissions) {
+    if (Platform.OS === 'android') {
+        return expoMediaLibrary.requestPermissionsAsync(writeOnly, granularPermissions);
+    }
+    return expoMediaLibrary.requestPermissionsAsync(writeOnly);
+}
+export async function getPermissionsAsync(writeOnly = false, granularPermissions) {
+    if (Platform.OS === 'android') {
+        return expoMediaLibrary.getPermissionsAsync(writeOnly, granularPermissions);
+    }
+    return expoMediaLibrary.getPermissionsAsync(writeOnly);
+}
+export const usePermissions = createPermissionHook({
+    getMethod: (options) => getPermissionsAsync(options?.writeOnly, options?.granularPermissions),
+    requestMethod: (options) => requestPermissionsAsync(options?.writeOnly, options?.granularPermissions),
+});
+/**
+ * Lets the user update which assets your app has access to. Only a no-op unless the user
+ * previously granted `'limited'` access.
+ * @platform android 14+
+ * @platform ios
+ */
+export async function presentPermissionsPickerAsync(mediaTypes = ['photo', 'video']) {
+    if (Platform.OS === 'android' && Platform.Version >= 34) {
+        await expoMediaLibrary.requestPermissionsAsync(false, mediaTypes);
+        return;
+    }
+    if (!expoMediaLibrary.presentPermissionsPickerAsync) {
+        throw new Error('presentPermissionsPickerAsync is not available on this platform.');
+    }
+    return expoMediaLibrary.presentPermissionsPickerAsync();
+}
+/**
+ * Creates an asset from an existing local file — the common case is a picture just taken by a
+ * camera. Requires write permission.
+ * @param localUri Must contain an extension. On Android it must be a local path (`file:///…`).
+ * @param album If provided, the asset is added to this album on creation.
+ */
+export async function createAssetAsync(localUri, album) {
+    if (!localUri || typeof localUri !== 'string') {
+        throw new Error('Invalid argument "localUri". It must be a string!');
+    }
+    const asset = await expoMediaLibrary.createAssetAsync(localUri, getId(album));
+    return Array.isArray(asset) ? asset[0] : asset;
+}
+/**
+ * Saves the file at `localUri` to the user's library. Unlike `createAssetAsync`, does not
+ * return the created asset. On iOS 11+ this can be called without the read/write permission as
+ * long as `Info.plist` carries `NSPhotoLibraryAddUsageDescription`.
+ */
+export async function saveToLibraryAsync(localUri) {
+    return expoMediaLibrary.saveToLibraryAsync(localUri);
+}
+/**
+ * On Android, copies assets from their current album into the given one by default — pass
+ * `copy: false` to move them instead. Copied assets show up twice in `getAssetsAsync`.
+ */
+export async function addAssetsToAlbumAsync(assets, album, copy = true) {
+    const assetIds = arrayize(assets).map(getId);
+    const albumId = getId(album);
+    assertAssetIds(assetIds);
+    if (!albumId || typeof albumId !== 'string') {
+        throw new Error('Invalid album ID. It must be a string!');
+    }
+    if (Platform.OS === 'ios') {
+        return expoMediaLibrary.addAssetsToAlbumAsync(assetIds, albumId);
+    }
+    return expoMediaLibrary.addAssetsToAlbumAsync(assetIds, albumId, !!copy);
+}
+/** On Android, an empty album is deleted automatically once its last asset is removed. */
+export async function removeAssetsFromAlbumAsync(assets, album) {
+    const assetIds = arrayize(assets).map(getId);
+    assertAssetIds(assetIds);
+    return expoMediaLibrary.removeAssetsFromAlbumAsync(assetIds, getId(album));
+}
+/**
+ * iOS removes the asset from every album it belongs to (behind a system confirmation dialog);
+ * Android keeps other albums' copies (an asset is strictly tied to one album there).
+ */
+export async function deleteAssetsAsync(assets) {
+    const assetIds = arrayize(assets).map(getId);
+    assertAssetIds(assetIds);
+    return expoMediaLibrary.deleteAssetsAsync(assetIds);
+}
+/**
+ * GPS location, local URI and EXIF metadata. Prefer this only when you need more than the
+ * fields already on `Asset` — it costs more than a plain list query.
+ */
+export async function getAssetInfoAsync(asset, options = {
+    shouldDownloadFromNetwork: true,
+}) {
+    const assetId = getId(asset);
+    assertAssetIds([assetId]);
+    const info = await expoMediaLibrary.getAssetInfoAsync(assetId, options);
+    return Array.isArray(info) ? info[0] : info;
+}
+/** @platform android */
+export async function getAssetContentUriAsync(asset) {
+    if (Platform.OS !== 'android') {
+        throw new Error('getAssetContentUriAsync is only available on Android.');
+    }
+    const assetId = getId(asset);
+    assertAssetIds([assetId]);
+    return expoMediaLibrary.getAssetContentUriAsync(assetId);
+}
+/**
+ * @return Depending on Android version, the root storage directory may be listed as an album
+ * titled `"0"`, or not listed at all.
+ */
+export async function getAlbumsAsync({ includeSmartAlbums = false, } = {}) {
+    return expoMediaLibrary.getAlbumsAsync({ includeSmartAlbums });
+}
+export async function getAlbumAsync(title) {
+    if (typeof title !== 'string') {
+        throw new Error('Album title must be a string!');
+    }
+    return expoMediaLibrary.getAlbumAsync(title);
+}
+/**
+ * `asset` (or `initialAssetLocalUri`) is required on Android — an empty album cannot be
+ * created on that platform.
+ */
+export async function createAlbumAsync(albumName, asset, copyAsset = true, initialAssetLocalUri) {
+    const assetId = getId(asset);
+    if (Platform.OS === 'android' &&
+        (typeof assetId !== 'string' || assetId.length === 0) &&
+        !initialAssetLocalUri) {
+        throw new Error('createAlbumAsync must be called with an asset or a localUri on Android.');
+    }
+    if (!albumName || typeof albumName !== 'string') {
+        throw new Error('Invalid argument "albumName". It must be a string!');
+    }
+    if (Platform.OS === 'ios') {
+        return expoMediaLibrary.createAlbumAsync(albumName, assetId, initialAssetLocalUri);
+    }
+    return expoMediaLibrary.createAlbumAsync(albumName, assetId, !!copyAsset, initialAssetLocalUri);
+}
+/**
+ * iOS keeps the assets in the main library unless `deleteAssets` is set; Android always drops
+ * an album's assets along with it.
+ */
+export async function deleteAlbumsAsync(albums, deleteAssets = false) {
+    const albumIds = arrayize(albums).map(getId);
+    assertAlbumIds(albumIds);
+    if (Platform.OS === 'android') {
+        return expoMediaLibrary.deleteAlbumsAsync(albumIds);
+    }
+    return expoMediaLibrary.deleteAlbumsAsync(albumIds, !!deleteAssets);
+}
+// UPSTREAM-BUG(expo): legacy/MediaLibrary.ts's own `arrayize()` passes any array through
+// unchanged, so a single `[key, ascending]` tuple in `sortBy` is misread as two independent
+// sort keys instead of one pair — the caller must double-nest it (`[[key, ascending]]`) to
+// sort by one key ascending. Ported verbatim for parity; see media-library.test.ts.
+export async function getAssetsAsync(assetsOptions = {}) {
+    const { first, after, album, sortBy, mediaType, createdAfter, createdBefore, mediaSubtypes, resolveWithFullInfo, } = assetsOptions;
+    if (first != null && first < 0) {
+        throw new Error('Option "first" must be a positive integer!');
+    }
+    const afterId = getId(after);
+    if (after != null &&
+        Platform.OS === 'android' &&
+        isNaN(parseInt(afterId, 10))) {
+        throw new Error('Option "after" must be a valid ID!');
+    }
+    const mediaTypeList = arrayize(mediaType || [MediaType.photo]);
+    mediaTypeList.forEach(assertMediaType);
+    return expoMediaLibrary.getAssetsAsync({
+        first: first == null ? 20 : first,
+        after: afterId,
+        album: getId(album),
+        sortBy: arrayize(sortBy).map(sortByOptionToString),
+        mediaType: mediaTypeList,
+        mediaSubtypes: arrayize(mediaSubtypes),
+        createdAfter: dateToNumber(createdAfter),
+        createdBefore: dateToNumber(createdBefore),
+        resolveWithFullInfo: resolveWithFullInfo ?? false,
+    });
+}
+/**
+ * @param listener Fired on Android with an empty object; on iOS with a real
+ * `MediaLibraryAssetsChangeEvent`, and also whenever the user updates per-asset access via
+ * `presentPermissionsPickerAsync()`.
+ */
+export function addListener(listener) {
+    return expoMediaLibrary.addListener(expoMediaLibrary.CHANGE_LISTENER_NAME, (event) => listener(event));
+}
+export function removeAllListeners() {
+    expoMediaLibrary.removeAllListeners(expoMediaLibrary.CHANGE_LISTENER_NAME);
+}
+/**
+ * A "moment" is a group of assets taken around the same place and time.
+ * @platform ios
+ */
+export async function getMomentsAsync() {
+    return expoMediaLibrary.getMomentsAsync();
+}
+/**
+ * Moves an album's content into the scoped-storage media directories, only where needed
+ * (Android R+, and only if the app lacks write permission to the album folder). No-op on iOS,
+ * web, and Android below R, or if the app already has write access.
+ */
+export async function migrateAlbumIfNeededAsync(album) {
+    if (!expoMediaLibrary.migrateAlbumIfNeededAsync)
+        return;
+    return expoMediaLibrary.migrateAlbumIfNeededAsync(getId(album));
+}
+/** Always `false` on iOS, web, and Android below R. */
+export async function albumNeedsMigrationAsync(album) {
+    if (!expoMediaLibrary.albumNeedsMigrationAsync)
+        return false;
+    return expoMediaLibrary.albumNeedsMigrationAsync(getId(album));
+}
+/** Adds or removes the asset from the system "Favorites" smart album. @platform ios */
+export async function setAssetFavoriteAsync(asset, isFavorite) {
+    if (Platform.OS !== 'ios') {
+        throw new Error('setAssetFavoriteAsync is only available on iOS.');
+    }
+    const assetId = getId(asset);
+    assertAssetIds([assetId]);
+    return expoMediaLibrary.setAssetFavoriteAsync(assetId, isFavorite);
+}

package/build/core/native-module.d.ts

@@ -0,0 +1,29 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { IGranularPermission, IMediaLibraryAlbum, IMediaLibraryAlbumsOptions, IMediaLibraryAsset, IMediaLibraryAssetInfo, IMediaLibraryAssetInfoQueryOptions, IMediaLibraryMediaTypeObject, IMediaLibraryPagedInfo, IMediaLibraryPermissionResponse, IMediaLibrarySortByObject } from './types';
+export type INativeMediaLibraryModule = {
+    MediaType: IMediaLibraryMediaTypeObject;
+    SortBy: IMediaLibrarySortByObject;
+    CHANGE_LISTENER_NAME: string;
+    addListener(eventName: string, listener: (event: unknown) => void): EventSubscription;
+    removeAllListeners(eventName: string): void;
+    requestPermissionsAsync(writeOnly: boolean, granularPermissions?: IGranularPermission[]): Promise<IMediaLibraryPermissionResponse>;
+    getPermissionsAsync(writeOnly: boolean, granularPermissions?: IGranularPermission[]): Promise<IMediaLibraryPermissionResponse>;
+    presentPermissionsPickerAsync?(): Promise<void>;
+    createAssetAsync(localUri: string, albumId?: string): Promise<IMediaLibraryAsset | IMediaLibraryAsset[]>;
+    saveToLibraryAsync(localUri: string): Promise<void>;
+    addAssetsToAlbumAsync(assetIds: string[], albumId: string, copy?: boolean): Promise<boolean>;
+    removeAssetsFromAlbumAsync(assetIds: string[], albumId: string | undefined): Promise<boolean>;
+    deleteAssetsAsync(assetIds: string[]): Promise<boolean>;
+    getAssetInfoAsync(assetId: string, options: IMediaLibraryAssetInfoQueryOptions): Promise<IMediaLibraryAssetInfo | IMediaLibraryAssetInfo[]>;
+    getAssetContentUriAsync(assetId: string): Promise<string>;
+    getAlbumsAsync(options: IMediaLibraryAlbumsOptions): Promise<IMediaLibraryAlbum[]>;
+    getAlbumAsync(title: string): Promise<IMediaLibraryAlbum>;
+    createAlbumAsync(albumName: string, assetId: string | undefined, copyOrInitialUri?: boolean | string, initialAssetLocalUri?: string): Promise<IMediaLibraryAlbum>;
+    deleteAlbumsAsync(albumIds: string[], deleteAssets?: boolean): Promise<boolean>;
+    getAssetsAsync(options: Record<string, unknown>): Promise<IMediaLibraryPagedInfo<IMediaLibraryAsset>>;
+    getMomentsAsync(): Promise<IMediaLibraryAlbum[]>;
+    migrateAlbumIfNeededAsync?(albumId: string | undefined): Promise<void>;
+    albumNeedsMigrationAsync?(albumId: string | undefined): Promise<boolean>;
+    setAssetFavoriteAsync(assetId: string, isFavorite: boolean): Promise<boolean>;
+};
+export declare const expoMediaLibrary: INativeMediaLibraryModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_MEDIA_LIBRARY_MODULE_NAME = 'ExpoMediaLibrary';
+export const expoMediaLibrary = requireNativeModule(EXPO_MEDIA_LIBRARY_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,126 @@
+import type { PermissionResponse } from 'expo-modules-core';
+export type IGranularPermission = 'audio' | 'photo' | 'video';
+export type IMediaLibraryMediaTypeValue = 'audio' | 'photo' | 'video' | 'unknown' | 'pairedVideo';
+/** @platform android 14+ */
+export type IMediaLibraryMediaTypeFilter = 'photo' | 'video';
+export type IMediaLibrarySortByKey = 'default' | 'mediaType' | 'width' | 'height' | 'creationTime' | 'modificationTime' | 'duration';
+export type IMediaLibrarySortByValue = [
+    IMediaLibrarySortByKey,
+    boolean
+] | IMediaLibrarySortByKey;
+export type IMediaLibraryMediaTypeObject = {
+    audio: 'audio';
+    photo: 'photo';
+    video: 'video';
+    unknown: 'unknown';
+};
+export type IMediaLibrarySortByObject = {
+    default: 'default';
+    mediaType: 'mediaType';
+    width: 'width';
+    height: 'height';
+    creationTime: 'creationTime';
+    modificationTime: 'modificationTime';
+    duration: 'duration';
+};
+/** @platform ios */
+export type IMediaLibraryMediaSubtype = 'depthEffect' | 'hdr' | 'highFrameRate' | 'livePhoto' | 'panorama' | 'screenshot' | 'stream' | 'timelapse' | 'spatialMedia' | 'videoCinematic';
+export type IMediaLibraryLocation = {
+    latitude: number;
+    longitude: number;
+};
+export type IMediaLibraryAsset = {
+    id: string;
+    filename: string;
+    /** `ph://*` (iOS), `file://*` (Android) */
+    uri: string;
+    mediaType: IMediaLibraryMediaTypeValue;
+    /** @platform ios */
+    mediaSubtypes?: IMediaLibraryMediaSubtype[];
+    width: number;
+    height: number;
+    creationTime: number;
+    modificationTime: number;
+    /** Seconds, for audio/video assets. */
+    duration: number;
+    /** @platform android */
+    albumId?: string;
+};
+export type IMediaLibraryAssetInfo = IMediaLibraryAsset & {
+    localUri?: string;
+    location?: IMediaLibraryLocation;
+    exif?: object;
+    /** @platform ios */
+    isFavorite?: boolean;
+    /** Only set when `shouldDownloadFromNetwork` is `false`. @platform ios */
+    isNetworkAsset?: boolean;
+    /** 1-8, see the EXIF orientation spec. Only for `mediaType: 'photo'`. @platform ios */
+    orientation?: number;
+    /** The video paired with a Live Photo. @platform ios */
+    pairedVideoAsset?: IMediaLibraryAsset | null;
+};
+export type IMediaLibraryAssetInfoQueryOptions = {
+    /** @default true — iOS iCloud assets only */
+    shouldDownloadFromNetwork?: boolean;
+};
+export type IMediaLibraryAssetsChangeEvent = {
+    /** `false` on Android — the platform never reports incremental detail. */
+    hasIncrementalChanges: boolean;
+    insertedAssets?: IMediaLibraryAsset[];
+    deletedAssets?: IMediaLibraryAsset[];
+    updatedAssets?: IMediaLibraryAsset[];
+};
+export type IMediaLibraryAlbumType = 'album' | 'moment' | 'smartAlbum';
+export type IMediaLibraryAlbum = {
+    id: string;
+    title: string;
+    assetCount: number;
+    /** @platform ios */
+    type?: IMediaLibraryAlbumType;
+    /** Only for `type: 'moment'`. @platform ios */
+    startTime: number;
+    /** Only for `type: 'moment'`. @platform ios */
+    endTime: number;
+    /** Only for `type: 'moment'`. @platform ios */
+    approximateLocation?: IMediaLibraryLocation;
+    /** Only for `type: 'moment'`. @platform ios */
+    locationNames?: string[];
+};
+export type IMediaLibraryAlbumsOptions = {
+    includeSmartAlbums?: boolean;
+};
+export type IMediaLibraryAssetRef = IMediaLibraryAsset | string;
+export type IMediaLibraryAlbumRef = IMediaLibraryAlbum | string;
+export type IMediaLibraryAssetsOptions = {
+    /** @default 20 */
+    first?: number;
+    /** Pass the previous page's `endCursor` to fetch the next page. */
+    after?: IMediaLibraryAssetRef;
+    album?: IMediaLibraryAlbumRef;
+    /** All keys sort descending by default; pass `[key, true]` for ascending. */
+    sortBy?: IMediaLibrarySortByValue[] | IMediaLibrarySortByValue;
+    /** @default MediaType.photo */
+    mediaType?: IMediaLibraryMediaTypeValue[] | IMediaLibraryMediaTypeValue;
+    /** @platform ios */
+    mediaSubtypes?: IMediaLibraryMediaSubtype[] | IMediaLibraryMediaSubtype;
+    createdAfter?: Date | number;
+    createdBefore?: Date | number;
+    /** @default false @platform android */
+    resolveWithFullInfo?: boolean;
+};
+export type IMediaLibraryPagedInfo<T> = {
+    assets: T[];
+    /** iOS: the ID of the last fetched asset. Android: its index. */
+    endCursor: string;
+    hasNextPage: boolean;
+    totalCount: number;
+};
+export type IMediaLibraryPermissionResponse = PermissionResponse & {
+    /**
+     * - `'all'` — full library access
+     * - `'limited'` — only selected photos (Android 14+, iOS 14+)
+     * - `'none'` — denied or not yet granted
+     */
+    accessPrivileges?: 'all' | 'limited' | 'none';
+};
+export type { PermissionResponse };

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/next/album.d.ts

@@ -0,0 +1,9 @@
+import { expoMediaLibraryNext } from './native-module';
+import { Asset } from './asset';
+/**
+ * A media album (collection of assets) on the device, matching upstream's own trivial subclass
+ * for every method but `getAssets()` — same reason as Query.exe(), see query.ts.
+ */
+export declare class Album extends expoMediaLibraryNext.Album {
+    getAssets(): Promise<Asset[]>;
+}

package/build/next/album.js

@@ -0,0 +1,12 @@
+import { expoMediaLibraryNext } from './native-module.js';
+import { Asset } from './asset.js';
+/**
+ * A media album (collection of assets) on the device, matching upstream's own trivial subclass
+ * for every method but `getAssets()` — same reason as Query.exe(), see query.ts.
+ */
+export class Album extends expoMediaLibraryNext.Album {
+    async getAssets() {
+        const results = await super.getAssets();
+        return results.map(result => new Asset(result.id));
+    }
+}

package/build/next/asset.d.ts

@@ -0,0 +1,13 @@
+import { expoMediaLibraryNext } from './native-module';
+import type { MediaSubtype } from './types';
+/**
+ * A single media asset on the device (image, video, or audio). Four getters are iOS-only on
+ * upstream's own native side; guarded here to fail with the same `UnavailabilityError` upstream
+ * throws rather than whatever the Android native method happens to do when called anyway.
+ */
+export declare class Asset extends expoMediaLibraryNext.Asset {
+    getMediaSubtypes(): Promise<MediaSubtype[]>;
+    getLivePhotoVideoUri(): Promise<string | null>;
+    getIsInCloud(): Promise<boolean>;
+    getOrientation(): Promise<number | null>;
+}

package/build/next/asset.js

@@ -0,0 +1,34 @@
+import { Platform } from 'react-native';
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoMediaLibraryNext } from './native-module.js';
+/**
+ * A single media asset on the device (image, video, or audio). Four getters are iOS-only on
+ * upstream's own native side; guarded here to fail with the same `UnavailabilityError` upstream
+ * throws rather than whatever the Android native method happens to do when called anyway.
+ */
+export class Asset extends expoMediaLibraryNext.Asset {
+    getMediaSubtypes() {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('MediaLibrary', 'getMediaSubtypes is only available on iOS');
+        }
+        return super.getMediaSubtypes();
+    }
+    getLivePhotoVideoUri() {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('MediaLibrary', 'getLivePhotoVideoUri is only available on iOS');
+        }
+        return super.getLivePhotoVideoUri();
+    }
+    getIsInCloud() {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('MediaLibrary', 'getIsInCloud is only available on iOS');
+        }
+        return super.getIsInCloud();
+    }
+    getOrientation() {
+        if (Platform.OS !== 'ios') {
+            throw new UnavailabilityError('MediaLibrary', 'getOrientation is only available on iOS');
+        }
+        return super.getOrientation();
+    }
+}

package/build/next/index.d.ts

@@ -0,0 +1,24 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { IGranularPermission, IMediaLibraryAssetsChangeEvent, IMediaLibraryNextPermissionResponse, IMediaTypeFilter, IPermissionHookOptions } from './types';
+export { Query } from './query';
+export { Asset } from './asset';
+export { Album } from './album';
+export * from './types';
+/**
+ * @param granularPermissions Only has an effect on Android 13+. Defaults to every possible
+ * permission — make sure your app manifest requests everything you pass here.
+ */
+export declare function requestPermissionsAsync(writeOnly?: boolean, granularPermissions?: IGranularPermission[]): Promise<IMediaLibraryNextPermissionResponse>;
+export declare function getPermissionsAsync(writeOnly?: boolean, granularPermissions?: IGranularPermission[]): Promise<IMediaLibraryNextPermissionResponse>;
+export declare const usePermissions: (options?: import("expo-modules-core").PermissionHookOptions<IPermissionHookOptions> | undefined) => [IMediaLibraryNextPermissionResponse | null, () => Promise<IMediaLibraryNextPermissionResponse>, () => Promise<IMediaLibraryNextPermissionResponse>];
+/**
+ * Allows the user to update the assets your app has access to. Only a no-op unless the user
+ * previously granted `'limited'` access.
+ */
+export declare function presentPermissionsPicker(mediaTypes?: IMediaTypeFilter[]): Promise<void>;
+/**
+ * Subscribes for updates in the user's media library. On Android it's invoked with an empty
+ * object — only iOS reports `insertedAssets`/`deletedAssets`/`updatedAssets`.
+ */
+export declare function addListener(listener: (event: IMediaLibraryAssetsChangeEvent) => void): EventSubscription;
+export declare function removeAllListeners(): void;

package/build/next/index.js

@@ -0,0 +1,44 @@
+import { Platform } from 'react-native';
+import { createPermissionHook, } from 'expo-modules-core';
+import { expoMediaLibraryNext } from './native-module.js';
+export { Query } from './query.js';
+export { Asset } from './asset.js';
+export { Album } from './album.js';
+export * from './types.js';
+/**
+ * @param granularPermissions Only has an effect on Android 13+. Defaults to every possible
+ * permission — make sure your app manifest requests everything you pass here.
+ */
+export async function requestPermissionsAsync(writeOnly = false, granularPermissions) {
+    if (Platform.OS === 'android') {
+        return expoMediaLibraryNext.requestPermissionsAsync(writeOnly, granularPermissions);
+    }
+    return expoMediaLibraryNext.requestPermissionsAsync(writeOnly);
+}
+export async function getPermissionsAsync(writeOnly = false, granularPermissions) {
+    if (Platform.OS === 'android') {
+        return expoMediaLibraryNext.getPermissionsAsync(writeOnly, granularPermissions);
+    }
+    return expoMediaLibraryNext.getPermissionsAsync(writeOnly);
+}
+export const usePermissions = createPermissionHook({
+    getMethod: (options) => getPermissionsAsync(options?.writeOnly, options?.granularPermissions),
+    requestMethod: (options) => requestPermissionsAsync(options?.writeOnly, options?.granularPermissions),
+});
+/**
+ * Allows the user to update the assets your app has access to. Only a no-op unless the user
+ * previously granted `'limited'` access.
+ */
+export async function presentPermissionsPicker(mediaTypes) {
+    return expoMediaLibraryNext.presentPermissionsPicker(mediaTypes);
+}
+/**
+ * Subscribes for updates in the user's media library. On Android it's invoked with an empty
+ * object — only iOS reports `insertedAssets`/`deletedAssets`/`updatedAssets`.
+ */
+export function addListener(listener) {
+    return expoMediaLibraryNext.addListener('mediaLibraryDidChange', listener);
+}
+export function removeAllListeners() {
+    expoMediaLibraryNext.removeAllListeners('mediaLibraryDidChange');
+}

package/build/next/native-module.d.ts

@@ -0,0 +1,78 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { AssetField, IAssetFieldValueMap, IAssetInfo, IAssetMetadata, ISortDescriptor } from './types';
+export declare class NativeMediaLibraryQuery {
+    constructor();
+    eq<T extends AssetField>(field: T, value: IAssetFieldValueMap[T]): this;
+    within<T extends AssetField>(field: T, value: IAssetFieldValueMap[T][]): this;
+    gt(field: AssetField, value: number): this;
+    gte(field: AssetField, value: number): this;
+    lt(field: AssetField, value: number): this;
+    lte(field: AssetField, value: number): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    orderBy(sortDescriptors: ISortDescriptor | AssetField): this;
+    album(album: NativeMediaLibraryAlbum): this;
+    exe(): Promise<NativeMediaLibraryAsset[]>;
+    exeForMetadata(): Promise<IAssetMetadata[]>;
+}
+export declare class NativeMediaLibraryAsset {
+    constructor(id: string);
+    id: string;
+    getCreationTime(): Promise<number | null>;
+    getDuration(): Promise<number | null>;
+    getFilename(): Promise<string>;
+    getHeight(): Promise<number>;
+    getMediaType(): Promise<string>;
+    getMediaSubtypes(): Promise<string[]>;
+    getLivePhotoVideoUri(): Promise<string | null>;
+    getIsInCloud(): Promise<boolean>;
+    getOrientation(): Promise<number | null>;
+    getModificationTime(): Promise<number | null>;
+    getShape(): Promise<{
+        width: number;
+        height: number;
+    } | null>;
+    getUri(): Promise<string>;
+    getWidth(): Promise<number>;
+    getInfo(): Promise<IAssetInfo>;
+    getAlbums(): Promise<NativeMediaLibraryAlbum[]>;
+    getLocation(): Promise<{
+        latitude: number;
+        longitude: number;
+    } | null>;
+    getExif(): Promise<Record<string, unknown>>;
+    delete(): Promise<void>;
+    getFavorite(): Promise<boolean>;
+    setFavorite(isFavorite: boolean): Promise<void>;
+    static create(filePath: string, album?: NativeMediaLibraryAlbum): Promise<NativeMediaLibraryAsset>;
+    static delete(assets: NativeMediaLibraryAsset[]): Promise<void>;
+}
+export declare class NativeMediaLibraryAlbum {
+    constructor(id: string);
+    id: string;
+    getAssets(): Promise<NativeMediaLibraryAsset[]>;
+    getTitle(): Promise<string>;
+    delete(): Promise<void>;
+    add(assets: NativeMediaLibraryAsset | NativeMediaLibraryAsset[]): Promise<void>;
+    removeAssets(assets: NativeMediaLibraryAsset[]): Promise<void>;
+    static create(name: string, assetsRefs: string[] | NativeMediaLibraryAsset[], moveAssets?: boolean): Promise<NativeMediaLibraryAlbum>;
+    static delete(albums: NativeMediaLibraryAlbum[], deleteAssets?: boolean): Promise<void>;
+    static get(title: string): Promise<NativeMediaLibraryAlbum | null>;
+    static getAll(): Promise<NativeMediaLibraryAlbum[]>;
+}
+export type INativeMediaLibraryNextModule = {
+    Query: typeof NativeMediaLibraryQuery;
+    Asset: typeof NativeMediaLibraryAsset;
+    Album: typeof NativeMediaLibraryAlbum;
+    getPermissionsAsync(writeOnly?: boolean, granularPermissions?: string[]): Promise<import('expo-modules-core').PermissionResponse>;
+    requestPermissionsAsync(writeOnly?: boolean, granularPermissions?: string[]): Promise<import('expo-modules-core').PermissionResponse>;
+    presentPermissionsPicker(mediaTypes?: string[]): Promise<void>;
+    addListener(eventName: 'mediaLibraryDidChange', listener: (event: {
+        hasIncrementalChanges: boolean;
+        insertedAssets?: string[];
+        deletedAssets?: string[];
+        updatedAssets?: string[];
+    }) => void): EventSubscription;
+    removeAllListeners(eventName: 'mediaLibraryDidChange'): void;
+};
+export declare const expoMediaLibraryNext: INativeMediaLibraryNextModule;