@kesha-antonov/react-native-background-downloader 4.5.4 → 4.5.5

package/lib/DownloadTask.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DownloadTask = void 0;
+const config_1 = require("./config");
+// Import shared native module getter to avoid duplicating TurboModule lookup
+// This is lazily imported to avoid circular dependency issues at module load time
+let getNativeModuleImpl = null;
+function getNativeModule() {
+    if (!getNativeModuleImpl)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        getNativeModuleImpl = require('./index').getNativeModule;
+    return getNativeModuleImpl();
+}
+class DownloadTask {
+    constructor(taskParams, originalTask) {
+        var _a, _b;
+        this.id = '';
+        this.metadata = {};
+        this.state = 'PENDING';
+        this.errorCode = 0;
+        this.bytesDownloaded = 0;
+        this.bytesTotal = 0;
+        this.id = taskParams.id;
+        if (taskParams.bytesDownloaded)
+            this.bytesDownloaded = taskParams.bytesDownloaded;
+        if (taskParams.bytesTotal)
+            this.bytesTotal = taskParams.bytesTotal;
+        if (taskParams.destination)
+            this.destination = (_a = taskParams.destination) !== null && _a !== void 0 ? _a : undefined;
+        this.metadata = (_b = this.tryParseJson(taskParams.metadata)) !== null && _b !== void 0 ? _b : {};
+        if (originalTask) {
+            this.beginHandler = originalTask.beginHandler;
+            this.progressHandler = originalTask.progressHandler;
+            this.doneHandler = originalTask.doneHandler;
+            this.errorHandler = originalTask.errorHandler;
+        }
+    }
+    // event listeners setters
+    begin(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('begin handler must be a function');
+        this.beginHandler = handler;
+        return this;
+    }
+    progress(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('progress handler must be a function');
+        this.progressHandler = handler;
+        return this;
+    }
+    done(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('done handler must be a function');
+        this.doneHandler = handler;
+        return this;
+    }
+    error(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('error handler must be a function');
+        this.errorHandler = handler;
+        return this;
+    }
+    // event listeners
+    onBegin(params) {
+        var _a;
+        this.state = 'DOWNLOADING';
+        this.bytesTotal = params.expectedBytes;
+        (_a = this.beginHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onProgress(params) {
+        var _a;
+        this.bytesDownloaded = params.bytesDownloaded;
+        this.bytesTotal = params.bytesTotal;
+        (_a = this.progressHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onDone(params) {
+        var _a;
+        this.state = 'DONE';
+        this.bytesDownloaded = params.bytesDownloaded;
+        this.bytesTotal = params.bytesTotal;
+        (_a = this.doneHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onError(params) {
+        var _a;
+        this.state = 'FAILED';
+        (_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    // methods
+    /**
+     * Update download parameters.
+     * If the task is paused, this will also update headers in the native layer.
+     * If the task is in-progress or completed, only the local JS object is updated.
+     *
+     * @param downloadParams - The new download parameters
+     * @returns Promise<boolean> - true if native headers were updated, false otherwise
+     */
+    async setDownloadParams(downloadParams) {
+        this.downloadParams = downloadParams;
+        // If task is paused, update headers in native layer
+        if (this.state === 'PAUSED' && downloadParams.headers) {
+            const headers = this.headersToUnsafeObject(downloadParams.headers);
+            if (headers) {
+                (0, config_1.log)('DownloadTask: setDownloadParams updating native headers', this.id);
+                return getNativeModule().updateTaskHeaders(this.id, headers);
+            }
+        }
+        return false;
+    }
+    async pause() {
+        (0, config_1.log)('DownloadTask: pause', this.id);
+        this.state = 'PAUSED';
+        await getNativeModule().pauseTask(this.id);
+    }
+    async resume() {
+        (0, config_1.log)('DownloadTask: resume', this.id);
+        this.state = 'DOWNLOADING';
+        this.errorCode = 0;
+        await getNativeModule().resumeTask(this.id);
+    }
+    start() {
+        var _a, _b, _c, _d, _e;
+        if (this.state !== 'PENDING') {
+            (0, config_1.log)('DownloadTask: start. Download already started, can\' start again... ', this.id);
+            (_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, { error: 'Download already started', errorCode: -1 });
+            return;
+        }
+        if (!this.downloadParams) {
+            (0, config_1.log)('DownloadTask: start. downloadParams is missing. "setDownloadParams" wasn\'t called before "start"', this.id);
+            (_b = this.errorHandler) === null || _b === void 0 ? void 0 : _b.call(this, { error: 'downloadParams is missing. setDownloadParams must be called before start', errorCode: -2 });
+            return;
+        }
+        this.state = 'DOWNLOADING';
+        // kick-off download after returning the task
+        getNativeModule().download({
+            id: this.id,
+            metadata: JSON.stringify(this.metadata),
+            progressInterval: config_1.config.progressInterval,
+            progressMinBytes: config_1.config.progressMinBytes,
+            ...this.downloadParams,
+            headers: this.headersToUnsafeObject(this.downloadParams.headers),
+            isAllowedOverRoaming: (_c = this.downloadParams.isAllowedOverRoaming) !== null && _c !== void 0 ? _c : false,
+            isAllowedOverMetered: (_d = this.downloadParams.isAllowedOverMetered) !== null && _d !== void 0 ? _d : false,
+            // iOS-only; ignored on Android. Falls back to the global setConfig default.
+            iosDataProtection: (_e = this.downloadParams.iosDataProtection) !== null && _e !== void 0 ? _e : config_1.config.iosDataProtection,
+        });
+    }
+    async stop() {
+        (0, config_1.log)('DownloadTask: stop', this.id);
+        this.state = 'STOPPED';
+        await getNativeModule().stopTask(this.id);
+    }
+    tryParseJson(metadata) {
+        var _a;
+        try {
+            if (typeof metadata === 'string')
+                return JSON.parse(metadata);
+            return (_a = metadata) !== null && _a !== void 0 ? _a : null;
+        }
+        catch (e) {
+            (0, config_1.log)('DownloadTask tryParseJson', e);
+            return null;
+        }
+    }
+    headersToUnsafeObject(headers) {
+        if (!headers)
+            return undefined;
+        // Filter out null values from headers to match native UnsafeObject type
+        return Object.keys(headers)
+            .reduce((mapped, key) => {
+            if (headers[key])
+                mapped[key] = headers[key];
+            return mapped;
+        }, {});
+    }
+}
+exports.DownloadTask = DownloadTask;

package/lib/NativeRNBackgroundDownloader.d.ts

@@ -0,0 +1,127 @@
+import type { TurboModule } from 'react-native';
+import type { EventEmitter } from 'react-native/Libraries/Types/CodegenTypes';
+import type { UnsafeObject } from './types';
+export type DownloadBeginEvent = {
+    id: string;
+    expectedBytes: number;
+    headers: UnsafeObject;
+};
+export type DownloadProgressEvent = {
+    id: string;
+    bytesDownloaded: number;
+    bytesTotal: number;
+};
+export type DownloadCompleteEvent = {
+    id: string;
+    location: string;
+    bytesDownloaded: number;
+    bytesTotal: number;
+};
+export type DownloadFailedEvent = {
+    id: string;
+    error: string;
+    errorCode: number;
+};
+export type UploadBeginEvent = {
+    id: string;
+    expectedBytes: number;
+};
+export type UploadProgressEvent = {
+    id: string;
+    bytesUploaded: number;
+    bytesTotal: number;
+};
+export type UploadCompleteEvent = {
+    id: string;
+    responseCode: number;
+    responseBody: string;
+    bytesUploaded: number;
+    bytesTotal: number;
+};
+export type UploadFailedEvent = {
+    id: string;
+    error: string;
+    errorCode: number;
+};
+export interface Spec extends TurboModule {
+    getConstants(): {
+        documents: string;
+        TaskRunning: number;
+        TaskSuspended: number;
+        TaskCanceling: number;
+        TaskCompleted: number;
+    };
+    download(options: {
+        id: string;
+        url: string;
+        destination: string;
+        headers?: UnsafeObject;
+        metadata?: string;
+        progressInterval?: number;
+        progressMinBytes?: number;
+        isAllowedOverRoaming: boolean;
+        isAllowedOverMetered: boolean;
+        maxRedirects?: number;
+        /** iOS only: NSFileProtection level for the saved file. Ignored on Android. */
+        iosDataProtection?: string;
+    }): void;
+    pauseTask(id: string): Promise<void>;
+    resumeTask(id: string): Promise<void>;
+    stopTask(id: string): Promise<void>;
+    updateTaskHeaders(id: string, headers: UnsafeObject): Promise<boolean>;
+    completeHandler(jobId: string): Promise<void>;
+    setLogsEnabled(enabled: boolean): void;
+    setMaxParallelDownloads(max: number): void;
+    setAllowsCellularAccess(allows: boolean): void;
+    setNotificationGroupingConfig?(config: {
+        enabled: boolean;
+        showNotificationsEnabled: boolean;
+        mode: string;
+        texts: UnsafeObject;
+    }): void;
+    getExistingDownloadTasks(): Promise<Array<{
+        id: string;
+        metadata: string;
+        state: number;
+        bytesDownloaded: number;
+        bytesTotal: number;
+        errorCode?: number | null;
+        destination?: string | null;
+    }>>;
+    upload?(options: {
+        id: string;
+        url: string;
+        source: string;
+        method: string;
+        headers?: UnsafeObject;
+        metadata?: string;
+        progressInterval?: number;
+        progressMinBytes?: number;
+        fieldName?: string;
+        mimeType?: string;
+        parameters?: UnsafeObject;
+        isAllowedOverRoaming: boolean;
+        isAllowedOverMetered: boolean;
+    }): void;
+    pauseUploadTask?(id: string): Promise<void>;
+    resumeUploadTask?(id: string): Promise<void>;
+    stopUploadTask?(id: string): Promise<void>;
+    getExistingUploadTasks?(): Promise<Array<{
+        id: string;
+        metadata: string;
+        state: number;
+        bytesUploaded: number;
+        bytesTotal: number;
+        errorCode?: number | null;
+    }>>;
+    readonly onDownloadBegin: EventEmitter<DownloadBeginEvent>;
+    readonly onDownloadProgress: EventEmitter<DownloadProgressEvent[]>;
+    readonly onDownloadComplete: EventEmitter<DownloadCompleteEvent>;
+    readonly onDownloadFailed: EventEmitter<DownloadFailedEvent>;
+    readonly onUploadBegin?: EventEmitter<UploadBeginEvent>;
+    readonly onUploadProgress?: EventEmitter<UploadProgressEvent[]>;
+    readonly onUploadComplete?: EventEmitter<UploadCompleteEvent>;
+    readonly onUploadFailed?: EventEmitter<UploadFailedEvent>;
+}
+declare const _default: Spec;
+export default _default;

package/lib/NativeRNBackgroundDownloader.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_native_1 = require("react-native");
+exports.default = react_native_1.TurboModuleRegistry.getEnforcing('RNBackgroundDownloader');

package/lib/UploadTask.d.ts

@@ -0,0 +1,30 @@
+import { UploadTaskInfo, UploadTask as UploadTaskType, UploadBeginHandler, UploadProgressHandler, UploadDoneHandler, UploadErrorHandler, UploadBeginHandlerParams, UploadProgressHandlerParams, UploadDoneHandlerParams, UploadErrorHandlerParams, UploadTaskInfoNative, UploadParams, UploadTaskState, Metadata } from './types';
+export declare class UploadTask {
+    id: string;
+    metadata: Metadata;
+    state: UploadTaskState;
+    errorCode: number;
+    bytesUploaded: number;
+    bytesTotal: number;
+    uploadParams?: UploadParams;
+    beginHandler?: UploadBeginHandler;
+    progressHandler?: UploadProgressHandler;
+    doneHandler?: UploadDoneHandler;
+    errorHandler?: UploadErrorHandler;
+    constructor(taskParams: UploadTaskInfo | UploadTaskInfoNative, originalTask?: UploadTaskType);
+    begin(handler: UploadBeginHandler): this;
+    progress(handler: UploadProgressHandler): this;
+    done(handler: UploadDoneHandler): this;
+    error(handler: UploadErrorHandler): this;
+    onBegin(params: UploadBeginHandlerParams): void;
+    onProgress(params: UploadProgressHandlerParams): void;
+    onDone(params: UploadDoneHandlerParams): void;
+    onError(params: UploadErrorHandlerParams): void;
+    setUploadParams(uploadParams: UploadParams): void;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    start(): void;
+    stop(): Promise<void>;
+    tryParseJson(metadata?: string | Metadata | object): Metadata | null;
+    private headersToUnsafeObject;
+}

package/lib/UploadTask.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadTask = void 0;
+const config_1 = require("./config");
+// Import shared native module getter to avoid duplicating TurboModule lookup
+// This is lazily imported to avoid circular dependency issues at module load time
+let getNativeModuleImpl = null;
+function getNativeModule() {
+    if (!getNativeModuleImpl)
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        getNativeModuleImpl = require('./index').getNativeModule;
+    return getNativeModuleImpl();
+}
+class UploadTask {
+    constructor(taskParams, originalTask) {
+        var _a;
+        this.id = '';
+        this.metadata = {};
+        this.state = 'PENDING';
+        this.errorCode = 0;
+        this.bytesUploaded = 0;
+        this.bytesTotal = 0;
+        this.id = taskParams.id;
+        if (taskParams.bytesUploaded)
+            this.bytesUploaded = taskParams.bytesUploaded;
+        if (taskParams.bytesTotal)
+            this.bytesTotal = taskParams.bytesTotal;
+        this.metadata = (_a = this.tryParseJson(taskParams.metadata)) !== null && _a !== void 0 ? _a : {};
+        if (originalTask) {
+            this.beginHandler = originalTask.beginHandler;
+            this.progressHandler = originalTask.progressHandler;
+            this.doneHandler = originalTask.doneHandler;
+            this.errorHandler = originalTask.errorHandler;
+        }
+    }
+    // event listeners setters
+    begin(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('begin handler must be a function');
+        this.beginHandler = handler;
+        return this;
+    }
+    progress(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('progress handler must be a function');
+        this.progressHandler = handler;
+        return this;
+    }
+    done(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('done handler must be a function');
+        this.doneHandler = handler;
+        return this;
+    }
+    error(handler) {
+        if (typeof handler !== 'function')
+            throw new Error('error handler must be a function');
+        this.errorHandler = handler;
+        return this;
+    }
+    // event listeners
+    onBegin(params) {
+        var _a;
+        this.state = 'UPLOADING';
+        this.bytesTotal = params.expectedBytes;
+        (_a = this.beginHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onProgress(params) {
+        var _a;
+        this.bytesUploaded = params.bytesUploaded;
+        this.bytesTotal = params.bytesTotal;
+        (_a = this.progressHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onDone(params) {
+        var _a;
+        this.state = 'DONE';
+        this.bytesUploaded = params.bytesUploaded;
+        this.bytesTotal = params.bytesTotal;
+        (_a = this.doneHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    onError(params) {
+        var _a;
+        this.state = 'FAILED';
+        (_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, params);
+    }
+    // methods
+    setUploadParams(uploadParams) {
+        this.uploadParams = uploadParams;
+    }
+    async pause() {
+        (0, config_1.log)('UploadTask: pause', this.id);
+        this.state = 'PAUSED';
+        const nativeModule = getNativeModule();
+        if (nativeModule.pauseUploadTask)
+            await nativeModule.pauseUploadTask(this.id);
+        else
+            (0, config_1.log)('UploadTask: pause not supported - native implementation missing');
+    }
+    async resume() {
+        (0, config_1.log)('UploadTask: resume', this.id);
+        this.state = 'UPLOADING';
+        this.errorCode = 0;
+        const nativeModule = getNativeModule();
+        if (nativeModule.resumeUploadTask)
+            await nativeModule.resumeUploadTask(this.id);
+        else
+            (0, config_1.log)('UploadTask: resume not supported - native implementation missing');
+    }
+    start() {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.state !== 'PENDING') {
+            (0, config_1.log)('UploadTask: start. Upload already started, can\' start again... ', this.id);
+            (_a = this.errorHandler) === null || _a === void 0 ? void 0 : _a.call(this, { error: 'Upload already started', errorCode: -1 });
+            return;
+        }
+        if (!this.uploadParams) {
+            (0, config_1.log)('UploadTask: start. uploadParams is missing. "setUploadParams" wasn\'t called before "start"', this.id);
+            (_b = this.errorHandler) === null || _b === void 0 ? void 0 : _b.call(this, { error: 'uploadParams is missing. setUploadParams must be called before start', errorCode: -2 });
+            return;
+        }
+        const nativeModule = getNativeModule();
+        if (!nativeModule.upload) {
+            (0, config_1.log)('UploadTask: start. Upload not supported - native implementation missing');
+            (_c = this.errorHandler) === null || _c === void 0 ? void 0 : _c.call(this, { error: 'Upload not supported - native implementation missing', errorCode: -3 });
+            return;
+        }
+        this.state = 'UPLOADING';
+        // kick-off upload after returning the task
+        nativeModule.upload({
+            id: this.id,
+            metadata: JSON.stringify(this.metadata),
+            progressInterval: config_1.config.progressInterval,
+            progressMinBytes: config_1.config.progressMinBytes,
+            ...this.uploadParams,
+            method: (_d = this.uploadParams.method) !== null && _d !== void 0 ? _d : 'POST',
+            headers: this.headersToUnsafeObject(this.uploadParams.headers),
+            isAllowedOverRoaming: (_e = this.uploadParams.isAllowedOverRoaming) !== null && _e !== void 0 ? _e : false,
+            isAllowedOverMetered: (_f = this.uploadParams.isAllowedOverMetered) !== null && _f !== void 0 ? _f : false,
+        });
+    }
+    async stop() {
+        (0, config_1.log)('UploadTask: stop', this.id);
+        this.state = 'STOPPED';
+        const nativeModule = getNativeModule();
+        if (nativeModule.stopUploadTask)
+            await nativeModule.stopUploadTask(this.id);
+        else
+            (0, config_1.log)('UploadTask: stop not supported - native implementation missing');
+    }
+    tryParseJson(metadata) {
+        var _a;
+        try {
+            if (typeof metadata === 'string')
+                return JSON.parse(metadata);
+            return (_a = metadata) !== null && _a !== void 0 ? _a : null;
+        }
+        catch (e) {
+            (0, config_1.log)('UploadTask tryParseJson', e);
+            return null;
+        }
+    }
+    headersToUnsafeObject(headers) {
+        if (!headers)
+            return undefined;
+        // Filter out null values from headers to match native UnsafeObject type
+        return Object.keys(headers)
+            .reduce((mapped, key) => {
+            if (headers[key])
+                mapped[key] = headers[key];
+            return mapped;
+        }, {});
+    }
+}
+exports.UploadTask = UploadTask;

package/lib/config.d.ts

@@ -0,0 +1,33 @@
+import { Headers, IosDataProtection, NotificationGroupingMode, NotificationsGroupingConfig, NotificationTexts } from './types';
+export declare const DEFAULT_PROGRESS_INTERVAL = 1000;
+export declare const DEFAULT_PROGRESS_MIN_BYTES: number;
+export declare const DEFAULT_MAX_PARALLEL_DOWNLOADS = 4;
+export declare const DEFAULT_ALLOWS_CELLULAR_ACCESS = true;
+export declare const DEFAULT_IOS_DATA_PROTECTION: IosDataProtection;
+export declare const DEFAULT_NOTIFICATION_TEXTS: Required<NotificationTexts>;
+type LogCallback = (tag: string, message: string, ...args: unknown[]) => void;
+interface ConfigState {
+    headers: Headers;
+    progressInterval: number;
+    progressMinBytes: number;
+    isLogsEnabled: boolean;
+    logCallback?: LogCallback;
+    maxParallelDownloads: number;
+    allowsCellularAccess: boolean;
+    showNotificationsEnabled: boolean;
+    notificationsGrouping: NotificationsGroupingConfig & {
+        mode: NotificationGroupingMode;
+    };
+    iosDataProtection: IosDataProtection;
+}
+export declare const config: ConfigState;
+/**
+ * Get notification text with proper pluralization.
+ */
+export declare function getGroupText(count: number): string;
+/**
+ * Get notification texts config for native side (serializable).
+ */
+export declare function getNotificationTextsForNative(): Record<string, string>;
+export declare const log: (...args: unknown[]) => void;
+export {};

package/lib/config.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = exports.config = exports.DEFAULT_NOTIFICATION_TEXTS = exports.DEFAULT_IOS_DATA_PROTECTION = exports.DEFAULT_ALLOWS_CELLULAR_ACCESS = exports.DEFAULT_MAX_PARALLEL_DOWNLOADS = exports.DEFAULT_PROGRESS_MIN_BYTES = exports.DEFAULT_PROGRESS_INTERVAL = void 0;
+exports.getGroupText = getGroupText;
+exports.getNotificationTextsForNative = getNotificationTextsForNative;
+exports.DEFAULT_PROGRESS_INTERVAL = 1000;
+exports.DEFAULT_PROGRESS_MIN_BYTES = 1024 * 1024; // 1MB
+exports.DEFAULT_MAX_PARALLEL_DOWNLOADS = 4;
+exports.DEFAULT_ALLOWS_CELLULAR_ACCESS = true;
+// Lets a background download save its file even while the device is locked
+// (after the first unlock since boot). See the iOS background-download notes in the README.
+exports.DEFAULT_IOS_DATA_PROTECTION = 'completeUntilFirstUserAuthentication';
+// Default notification texts
+exports.DEFAULT_NOTIFICATION_TEXTS = {
+    downloadTitle: 'Download',
+    downloadStarting: 'Starting download...',
+    downloadProgress: 'Downloading... {progress}%',
+    downloadPaused: 'Paused',
+    downloadFinished: 'Download complete',
+    groupTitle: 'Downloads',
+    groupText: (count) => `${count} download${count !== 1 ? 's' : ''} in progress`,
+};
+exports.config = {
+    headers: {},
+    progressInterval: exports.DEFAULT_PROGRESS_INTERVAL,
+    progressMinBytes: exports.DEFAULT_PROGRESS_MIN_BYTES,
+    isLogsEnabled: false,
+    logCallback: undefined,
+    maxParallelDownloads: exports.DEFAULT_MAX_PARALLEL_DOWNLOADS,
+    allowsCellularAccess: exports.DEFAULT_ALLOWS_CELLULAR_ACCESS,
+    showNotificationsEnabled: false,
+    iosDataProtection: exports.DEFAULT_IOS_DATA_PROTECTION,
+    notificationsGrouping: {
+        enabled: false,
+        mode: 'individual',
+        texts: exports.DEFAULT_NOTIFICATION_TEXTS,
+    },
+};
+/**
+ * Get notification text with proper pluralization.
+ */
+function getGroupText(count) {
+    var _a, _b;
+    const groupText = (_b = (_a = exports.config.notificationsGrouping.texts) === null || _a === void 0 ? void 0 : _a.groupText) !== null && _b !== void 0 ? _b : exports.DEFAULT_NOTIFICATION_TEXTS.groupText;
+    if (typeof groupText === 'function')
+        return groupText(count);
+    return groupText.replace('{count}', String(count));
+}
+/**
+ * Get notification texts config for native side (serializable).
+ */
+function getNotificationTextsForNative() {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const texts = (_a = exports.config.notificationsGrouping.texts) !== null && _a !== void 0 ? _a : exports.DEFAULT_NOTIFICATION_TEXTS;
+    return {
+        downloadTitle: (_b = texts.downloadTitle) !== null && _b !== void 0 ? _b : exports.DEFAULT_NOTIFICATION_TEXTS.downloadTitle,
+        downloadStarting: (_c = texts.downloadStarting) !== null && _c !== void 0 ? _c : exports.DEFAULT_NOTIFICATION_TEXTS.downloadStarting,
+        downloadProgress: (_d = texts.downloadProgress) !== null && _d !== void 0 ? _d : exports.DEFAULT_NOTIFICATION_TEXTS.downloadProgress,
+        downloadPaused: (_e = texts.downloadPaused) !== null && _e !== void 0 ? _e : exports.DEFAULT_NOTIFICATION_TEXTS.downloadPaused,
+        downloadFinished: (_f = texts.downloadFinished) !== null && _f !== void 0 ? _f : exports.DEFAULT_NOTIFICATION_TEXTS.downloadFinished,
+        groupTitle: (_g = texts.groupTitle) !== null && _g !== void 0 ? _g : exports.DEFAULT_NOTIFICATION_TEXTS.groupTitle,
+        // For native side, we send a pattern with {count} placeholder
+        groupText: typeof texts.groupText === 'function'
+            ? '{count} download(s) in progress' // Default pattern if function provided
+            : ((_h = texts.groupText) !== null && _h !== void 0 ? _h : '{count} download(s) in progress'),
+    };
+}
+const log = (...args) => {
+    if (exports.config.isLogsEnabled) {
+        console.log('[RNBackgroundDownloader]', ...args);
+        // Call external log callback if provided
+        if (exports.config.logCallback) {
+            const message = args.length > 0 && typeof args[0] === 'string' ? args[0] : 'log';
+            const restArgs = args.length > 1 ? args.slice(1) : [];
+            exports.config.logCallback('RNBD', message, ...restArgs);
+        }
+    }
+};
+exports.log = log;

package/lib/index.d.ts

@@ -0,0 +1,26 @@
+import { DownloadTask } from './DownloadTask';
+import { UploadTask } from './UploadTask';
+import { Config, DownloadParams, TaskInfo, UploadParams, UploadTaskInfo } from './types';
+import type { Spec } from './NativeRNBackgroundDownloader';
+/**
+ * Clean up event listeners. Call this before hot reload or module invalidation.
+ * This prevents memory leaks from accumulated event listeners.
+ */
+export declare function cleanup(): void;
+export declare function setConfig({ headers, progressInterval, progressMinBytes, isLogsEnabled, logCallback, maxParallelDownloads, allowsCellularAccess, showNotificationsEnabled, notificationsGrouping, iosDataProtection, }: Config): void;
+export declare const getExistingDownloadTasks: () => Promise<DownloadTask[]>;
+export declare const completeHandler: (jobId: string) => Promise<void> | undefined;
+export declare function createDownloadTask({ isAllowedOverRoaming, isAllowedOverMetered, metadata, ...rest }: TaskInfo & DownloadParams): DownloadTask;
+export declare const getExistingUploadTasks: () => Promise<UploadTask[]>;
+export declare function createUploadTask({ isAllowedOverRoaming, isAllowedOverMetered, metadata, ...rest }: UploadTaskInfo & UploadParams): UploadTask;
+export declare const directories: {
+    readonly documents: string;
+};
+/**
+ * Get the native module instance.
+ * This is exported for internal use by DownloadTask to avoid duplicating
+ * the TurboModule/NativeModule lookup logic.
+ * @internal
+ */
+export declare function getNativeModule(): Spec;
+export type * from './types';