react-native-asset 2.1.1 → 2.2.0-rc1

package/esm/deps/jsr.io/@std/path/1.1.3/windows/resolve.js

@@ -0,0 +1,154 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { CHAR_COLON } from "../_common/constants.js";
+import { normalizeString } from "../_common/normalize_string.js";
+import { assertPath } from "../_common/assert_path.js";
+import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
+/**
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/windows/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const resolved = resolve("C:\\foo\\bar", "..\\baz");
+ * assertEquals(resolved, "C:\\foo\\baz");
+ * ```
+ *
+ * @param pathSegments The path segments to process to path
+ * @returns The resolved path
+ */
+export function resolve(...pathSegments) {
+    let resolvedDevice = "";
+    let resolvedTail = "";
+    let resolvedAbsolute = false;
+    for (let i = pathSegments.length - 1; i >= -1; i--) {
+        let path;
+        // deno-lint-ignore no-explicit-any
+        const { Deno } = dntShim.dntGlobalThis;
+        if (i >= 0) {
+            path = pathSegments[i];
+        }
+        else if (!resolvedDevice) {
+            if (typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a drive-letter-less path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+        }
+        else {
+            if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a relative path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+            // Verify that a cwd was found and that it actually points
+            // to our drive. If not, default to the drive's root.
+            if (path === undefined ||
+                path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) {
+                path = `${resolvedDevice}\\`;
+            }
+        }
+        assertPath(path);
+        const len = path.length;
+        // Skip empty entries
+        if (len === 0)
+            continue;
+        let rootEnd = 0;
+        let device = "";
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        // Try to match a root
+        if (len > 1) {
+            if (isPathSeparator(code)) {
+                // Possible UNC root
+                // If we started with a separator, we know we at least have an
+                // absolute path of some kind (UNC or otherwise)
+                isAbsolute = true;
+                if (isPathSeparator(path.charCodeAt(1))) {
+                    // Matched double path separator at beginning
+                    let j = 2;
+                    let last = j;
+                    // Match 1 or more non-path separators
+                    for (; j < len; ++j) {
+                        if (isPathSeparator(path.charCodeAt(j)))
+                            break;
+                    }
+                    if (j < len && j !== last) {
+                        const firstPart = path.slice(last, j);
+                        // Matched!
+                        last = j;
+                        // Match 1 or more path separators
+                        for (; j < len; ++j) {
+                            if (!isPathSeparator(path.charCodeAt(j)))
+                                break;
+                        }
+                        if (j < len && j !== last) {
+                            // Matched!
+                            last = j;
+                            // Match 1 or more non-path separators
+                            for (; j < len; ++j) {
+                                if (isPathSeparator(path.charCodeAt(j)))
+                                    break;
+                            }
+                            if (j === len) {
+                                // We matched a UNC root only
+                                device = `\\\\${firstPart}\\${path.slice(last)}`;
+                                rootEnd = j;
+                            }
+                            else if (j !== last) {
+                                // We matched a UNC root with leftovers
+                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                                rootEnd = j;
+                            }
+                        }
+                    }
+                }
+                else {
+                    rootEnd = 1;
+                }
+            }
+            else if (isWindowsDeviceRoot(code)) {
+                // Possible device root
+                if (path.charCodeAt(1) === CHAR_COLON) {
+                    device = path.slice(0, 2);
+                    rootEnd = 2;
+                    if (len > 2) {
+                        if (isPathSeparator(path.charCodeAt(2))) {
+                            // Treat separator following drive name as an absolute path
+                            // indicator
+                            isAbsolute = true;
+                            rootEnd = 3;
+                        }
+                    }
+                }
+            }
+        }
+        else if (isPathSeparator(code)) {
+            // `path` contains just a path separator
+            rootEnd = 1;
+            isAbsolute = true;
+        }
+        if (device.length > 0 &&
+            resolvedDevice.length > 0 &&
+            device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+            // This path points to another device so it is not applicable
+            continue;
+        }
+        if (resolvedDevice.length === 0 && device.length > 0) {
+            resolvedDevice = device;
+        }
+        if (!resolvedAbsolute) {
+            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+            resolvedAbsolute = isAbsolute;
+        }
+        if (resolvedAbsolute && resolvedDevice.length > 0)
+            break;
+    }
+    // At this point the path should be resolved to a full absolute path,
+    // but handle relative paths to be safe (might happen when Deno.cwd()
+    // fails)
+    // Normalize the tail path
+    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
+    return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
+}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_file_url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export declare function toFileUrl(path: string): URL;
+//# sourceMappingURL=to_file_url.d.ts.map

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/windows/to_file_url.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAgB3C"}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_file_url.js

@@ -0,0 +1,34 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { encodeWhitespace } from "../_common/to_file_url.js";
+import { isAbsolute } from "./is_absolute.js";
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export function toFileUrl(path) {
+    if (!isAbsolute(path)) {
+        throw new TypeError(`Path must be absolute: received "${path}"`);
+    }
+    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+    const url = new URL("file:///");
+    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+    if (hostname !== undefined && hostname !== "localhost") {
+        url.hostname = hostname;
+        if (!url.hostname) {
+            throw new TypeError(`Invalid hostname: "${url.hostname}"`);
+        }
+    }
+    return url;
+}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export declare function toNamespacedPath(path: string): string;
+//# sourceMappingURL=to_namespaced_path.d.ts.map

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_namespaced_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgCrD"}

package/esm/deps/jsr.io/@std/path/1.1.3/windows/to_namespaced_path.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
+import { isWindowsDeviceRoot } from "./_util.js";
+import { resolve } from "./resolve.js";
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = resolve(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}

package/esm/get-config.d.ts

@@ -0,0 +1,14 @@
+export declare const getConfig: ({ rootPath }: {
+    rootPath: string;
+}) => Promise<{
+    android: {
+        path: string;
+        exists: boolean;
+    };
+    ios: {
+        path: string;
+        exists: boolean;
+        pbxprojPath: string | undefined;
+    };
+}>;
+//# sourceMappingURL=get-config.d.ts.map

package/esm/get-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-config.d.ts","sourceRoot":"","sources":["../src/get-config.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,GAAU,cAAc;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;EAwCjE,CAAC"}

package/esm/get-config.js

@@ -0,0 +1,41 @@
+import * as dntShim from "./_dnt.shims.js";
+import * as path from "./deps/jsr.io/@std/path/1.1.3/mod.js";
+export const getConfig = async ({ rootPath }) => {
+    const androidPath = path.resolve(rootPath, "android");
+    const iosPath = path.resolve(rootPath, "ios");
+    let androidExists = false;
+    let iosExists = false;
+    try {
+        const st = await dntShim.Deno.lstat(androidPath);
+        androidExists = st.isDirectory;
+    }
+    catch (_e) {
+        // Ok
+    }
+    let pbxprojPath = undefined;
+    try {
+        const st = await dntShim.Deno.lstat(iosPath);
+        iosExists = st.isDirectory;
+        for await (const dir of dntShim.Deno.readDir(iosPath)) {
+            if (dir.isDirectory && dir.name.endsWith(".xcodeproj")) {
+                const pbxproj = path.resolve(iosPath, dir.name, "project.pbxproj");
+                pbxprojPath = pbxproj;
+                break;
+            }
+        }
+    }
+    catch (_e) {
+        // Ok
+    }
+    return {
+        android: {
+            path: androidPath,
+            exists: androidExists,
+        },
+        ios: {
+            path: iosPath,
+            exists: iosExists,
+            pbxprojPath,
+        },
+    };
+};

package/esm/main.d.ts

@@ -0,0 +1,11 @@
+type PlatformType = "ios" | "android";
+export declare const linkAssets: ({ rootPath, platforms, shouldUnlink, }: {
+    rootPath: string;
+    shouldUnlink?: boolean;
+    platforms: { [k in PlatformType]: {
+        enabled: boolean;
+        assets: string[];
+    }; };
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=main.d.ts.map

package/esm/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AASA,KAAK,YAAY,GAAG,KAAK,GAAG,SAAS,CAAC;AAEtC,eAAO,MAAM,UAAU,GACrB,wCAIG;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,GACR,CAAC,IAAI,YAAY,GAAG;QACnB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,EAAE,MAAM,EAAE,CAAC;KAClB,GACF,CAAC;CACH,KACA,OAAO,CAAC,IAAI,CAiXd,CAAC"}

package/esm/main.js

@@ -0,0 +1,235 @@
+import * as dntShim from "./_dnt.shims.js";
+import * as path from "./deps/jsr.io/@std/path/1.1.3/mod.js";
+import { getConfig } from "./get-config.js";
+import copyAssetsIos from "./copy-assets/ios.js";
+import cleanAssetsIos from "./clean-assets/ios.js";
+import copyAssetsAndroid from "./copy-assets/android.js";
+import cleanAssetsAndroid from "./clean-assets/android.js";
+import getManifest from "./manifest/index.js";
+export const linkAssets = async ({ rootPath, platforms, shouldUnlink = true, }) => {
+    const cwd = dntShim.Deno.cwd();
+    const clearDuplicated = (files) => Array.from(new Map(files.map((f) => [path.parse(f.path).base + "|" + f.sha1, f]))
+        .values());
+    const filesToIgnore = [
+        ".DS_Store",
+        "Thumbs.db",
+    ];
+    const filterFilesToIgnore = ({ path: asset }) => filesToIgnore.indexOf(path.basename(asset)) === -1;
+    const getAbsolute = ({ filePath, dirPath }) => (path.isAbsolute(filePath) ? filePath : path.resolve(dirPath, filePath));
+    const getRelative = ({ filePath, dirPath }) => (path.isAbsolute(filePath) ? path.relative(dirPath, filePath) : filePath);
+    const filterFileByFilesWhichNotExists = (files, { normalizeAbsolutePathsTo }) => (file) => {
+        const { path: filePath, sha1: fileSha1 } = file;
+        const relativeFilePath = getRelative({
+            filePath,
+            dirPath: normalizeAbsolutePathsTo,
+        });
+        return files
+            .map((otherFile) => ({
+            ...otherFile,
+            path: getRelative({
+                filePath: otherFile.path,
+                dirPath: normalizeAbsolutePathsTo,
+            }),
+        }))
+            .findIndex((otherFile) => {
+            const { path: otherFileRelativePath, sha1: otherFileSha1 } = otherFile;
+            return (relativeFilePath === otherFileRelativePath &&
+                fileSha1 === otherFileSha1);
+        }) === -1;
+    };
+    const computeSha1 = async (filePath) => {
+        const data = await dntShim.Deno.readFile(filePath);
+        const hashBuffer = await crypto.subtle.digest("SHA-1", data);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    };
+    const absoluteRootPath = path.resolve(cwd, rootPath);
+    console.log(`Linking assets in ${absoluteRootPath}`);
+    // basic validation
+    const st = await dntShim.Deno.lstat(rootPath);
+    if (!st.isDirectory) {
+        throw new Error(`'rootPath' must be a valid path, got ${rootPath}`);
+    }
+    const st2 = await dntShim.Deno.lstat(absoluteRootPath);
+    if (!st2.isDirectory) {
+        throw new Error(`'rootPath' must be a valid path, got ${absoluteRootPath}`);
+    }
+    if (typeof shouldUnlink !== "boolean") {
+        throw new Error(`'shouldUnlink' must be a boolean, got ${typeof shouldUnlink}`);
+    }
+    if ([platforms.ios, platforms.android].find(({ assets }) => !Array.isArray(assets))) {
+        throw new Error("'platforms[\"platform\"].assets' must be an array");
+    }
+    const finalRootPath = path.isAbsolute(rootPath)
+        ? rootPath
+        : path.resolve(cwd, rootPath);
+    // build platforms defaults
+    const mergedPlatforms = {
+        ios: {
+            enabled: platforms.ios.enabled,
+            assets: platforms.ios.assets,
+        },
+        android: {
+            enabled: platforms.android.enabled,
+            assets: platforms.android.assets,
+        },
+    };
+    // helper modules are statically imported at the top of this file
+    const config = await getConfig({ rootPath: finalRootPath });
+    const { android: { path: androidPath }, ios: { path: iosPath }, } = config;
+    const linkOptionsPerExt = {
+        ...["otf", "ttf"].reduce((result, fontType) => ({
+            ...result,
+            [fontType]: {
+                android: {
+                    path: path.resolve(androidPath, "app", "src", "main", "assets", "fonts"),
+                },
+                ios: {
+                    addFont: true,
+                },
+            },
+        }), {}),
+        ...["png", "jpg", "gif"].reduce((result, imageType) => ({
+            ...result,
+            [imageType]: {
+                android: {
+                    path: path.resolve(androidPath, "app", "src", "main", "res", "drawable"),
+                },
+                ios: {
+                    addFont: false,
+                },
+            },
+        }), {}),
+        mp3: {
+            android: {
+                path: path.resolve(androidPath, "app", "src", "main", "res", "raw"),
+            },
+            ios: {
+                addFont: false,
+            },
+        },
+    };
+    const otherLinkOptions = {
+        android: {
+            path: path.resolve(androidPath, "app", "src", "main", "assets", "custom"),
+        },
+        ios: {
+            addFont: false,
+        },
+    };
+    const linkPlatform = ({ rootPath: rp, shouldUnlink: su }) => async ({ name, manifest, config: platformConfig, linkOptionsPerExt: lopExt, otherLinkOptions: otherOptions, cleanAssets, copyAssets, assets: assetsPaths, }) => {
+        let prevRelativeAssets = [];
+        try {
+            prevRelativeAssets = (await manifest.read()).map((asset) => ({
+                ...asset,
+                path: asset.path.split("/").join(path.SEPARATOR),
+            }));
+        }
+        catch (_) {
+            // manifest not found -> ok
+        }
+        let assets = [];
+        const loadAsset = async (assetMightNotAbsolute) => {
+            const asset = getAbsolute({
+                filePath: assetMightNotAbsolute,
+                dirPath: rp,
+            });
+            const stats = await dntShim.Deno.lstat(asset);
+            if (stats.isDirectory) {
+                for await (const dirent of dntShim.Deno.readDir(asset)) {
+                    await loadAsset(path.resolve(asset, dirent.name));
+                }
+            }
+            else {
+                const sha1 = await computeSha1(asset);
+                assets = assets.concat({ path: asset, sha1 });
+            }
+        };
+        const loadAll = async () => {
+            for (const p of assetsPaths) {
+                await loadAsset(p);
+            }
+            assets = clearDuplicated(assets);
+        };
+        // run loading synchronously for simplicity
+        // (keeps behavior similar to original)
+        await loadAll();
+        const fileFilters = []
+            .concat(Object.keys(lopExt).map((fileExt) => ({
+            name: fileExt,
+            filter: ({ path: filePath }) => path.extname(filePath) === `.${fileExt}`,
+            options: lopExt[fileExt],
+        })))
+            .concat({
+            name: "custom",
+            filter: ({ path: filePath }) => Object.keys(lopExt).indexOf(path.extname(filePath).substr(1)) ===
+                -1,
+            options: otherOptions,
+        });
+        for (const { name: fileConfigName, filter: fileConfigFilter, options } of fileFilters) {
+            const prevRelativeAssetsWithExt = prevRelativeAssets
+                .filter(fileConfigFilter)
+                .filter(filterFileByFilesWhichNotExists(assets, {
+                normalizeAbsolutePathsTo: rp,
+            }));
+            const assetsWithExt = assets
+                .filter(fileConfigFilter)
+                .filter(filterFileByFilesWhichNotExists(prevRelativeAssets, {
+                normalizeAbsolutePathsTo: rp,
+            }))
+                .filter(filterFilesToIgnore);
+            if (su && prevRelativeAssetsWithExt.length > 0) {
+                console.info(`Cleaning previously linked ${fileConfigName} assets from ${name} project`);
+                await cleanAssets(prevRelativeAssetsWithExt.map(({ path: filePath }) => getAbsolute({ filePath, dirPath: rp })), platformConfig, options);
+            }
+            if (assetsWithExt.length > 0) {
+                console.info(`Linking ${fileConfigName} assets to ${name} project`);
+                await copyAssets(assetsWithExt.map(({ path: assetPath }) => assetPath), platformConfig, options);
+            }
+        }
+        await manifest.write(assets
+            .filter(filterFilesToIgnore)
+            .map((asset) => ({
+            ...asset,
+            path: path.relative(rp, asset.path).split(path.SEPARATOR).join("/"),
+        })));
+    };
+    const platformsArray = [
+        {
+            name: "iOS",
+            enabled: mergedPlatforms.ios.enabled,
+            assets: mergedPlatforms.ios.assets,
+            manifest: getManifest(iosPath),
+            config: config.ios,
+            cleanAssets: cleanAssetsIos,
+            copyAssets: copyAssetsIos,
+            linkOptionsPerExt: {
+                otf: linkOptionsPerExt.otf.ios,
+                ttf: linkOptionsPerExt.ttf.ios,
+                mp3: linkOptionsPerExt.mp3.ios,
+            },
+            otherLinkOptions: otherLinkOptions.ios,
+        },
+        {
+            name: "Android",
+            enabled: mergedPlatforms.android.enabled,
+            assets: mergedPlatforms.android.assets,
+            manifest: getManifest(androidPath),
+            config: config.android,
+            cleanAssets: cleanAssetsAndroid,
+            copyAssets: copyAssetsAndroid,
+            linkOptionsPerExt: {
+                otf: linkOptionsPerExt.otf.android,
+                ttf: linkOptionsPerExt.ttf.android,
+                png: linkOptionsPerExt.png.android,
+                jpg: linkOptionsPerExt.jpg.android,
+                gif: linkOptionsPerExt.gif.android,
+                mp3: linkOptionsPerExt.mp3.android,
+            },
+            otherLinkOptions: otherLinkOptions.android,
+        },
+    ];
+    await Promise.all(platformsArray
+        .filter(({ enabled, config: platformConfig }) => enabled && platformConfig.exists)
+        .map((p) => linkPlatform({ rootPath: finalRootPath, shouldUnlink })(p)));
+};

package/esm/manifest/index.d.ts

@@ -0,0 +1,11 @@
+export default function getManifest(projectPath: string): {
+    read: () => Promise<{
+        path: string;
+        sha1?: string;
+    }[]>;
+    write: (files: Array<{
+        path: string;
+        sha1?: string;
+    }>) => Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/esm/manifest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/manifest/index.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,WAAW,EAAE,MAAM;;cAON,MAAM;eAAS,MAAM;;mBAK7C,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;EAc9D"}

package/esm/manifest/index.js

@@ -0,0 +1,32 @@
+import * as dntShim from "../_dnt.shims.js";
+import * as path from "../deps/jsr.io/@std/path/1.1.3/mod.js";
+const manifestFileName = "react-native-assets-manifest.json";
+export default function getManifest(projectPath) {
+    const manifestPath = path.resolve(projectPath, manifestFileName);
+    return {
+        read: async () => {
+            try {
+                const data = await dntShim.Deno.readTextFile(manifestPath);
+                return JSON.parse(data);
+            }
+            catch (_) {
+                return [];
+            }
+        },
+        write: async (files) => {
+            try {
+                const dir = path.dirname(manifestPath);
+                try {
+                    dntShim.Deno.lstatSync(dir);
+                }
+                catch (_) {
+                    await dntShim.Deno.mkdir(dir, { recursive: true });
+                }
+                await dntShim.Deno.writeTextFile(manifestPath, JSON.stringify(files, null, 2));
+            }
+            catch (e) {
+                throw e;
+            }
+        },
+    };
+}

package/esm/mod.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./_dnt.polyfills.js";
+import "./_dnt.polyfills.js";
+export { linkAssets } from "./main.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../src/mod.ts"],"names":[],"mappings":";AACA,OAAO,qBAAqB,CAAC;AAC7B,OAAO,qBAAqB,CAAC;AAE7B,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC"}

package/esm/mod.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import "./_dnt.polyfills.js";
+import "./_dnt.polyfills.js";
+import * as dntShim from "./_dnt.shims.js";
+export { linkAssets } from "./main.js";
+import { runCli } from "./cli.js";
+if (globalThis[Symbol.for("import-meta-ponyfill-esmodule")](import.meta).main) {
+    runCli().catch((e) => {
+        console.error("Error running CLI:", e);
+        dntShim.Deno.exit(1);
+    });
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}